#include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
inline long long read() {
  long long f = 1, x = 0;
  char ch = getchar();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9') {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * f;
}
int stack[20];
template <typename T>
inline void write(T x) {
  if (x < 0) {
    putchar('-');
    x = -x;
  }
  if (!x) {
    putchar('0');
    return;
  }
  int top = 0;
  while (x) stack[++top] = x % 10, x /= 10;
  while (top) putchar(stack[top--] + '0');
}
template <typename T>
inline void pr1(T x) {
  write(x);
  putchar(' ');
}
template <typename T>
inline void pr2(T x) {
  write(x);
  putchar('\n');
}
template <typename T>
inline void chkmin(T &x, T y) {
  x = x < y ? x : y;
}
template <typename T>
inline void chkmax(T &x, T y) {
  x = x > y ? x : y;
}
const int mod = 1e9 + 7;
const int MAXN = 300005;
const double PI = acos(-1.0);
int pow_mod(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1, a = 1LL * a * a % mod)
    if (b & 1) ret = 1LL * ret * a % mod;
  return ret;
}
int pre[MAXN * 4], inv[MAXN * 4], n, m, K;
int C(int n, int m) { return 1LL * pre[n] * inv[m] % mod * inv[n - m] % mod; }
void ad(int &x, int y) {
  x += y;
  if (x >= mod) x -= mod;
}
const int M = sqrt(mod);
struct Complex {
  long double r, i;
  Complex() {}
  Complex(long double _r, long double _i) {
    r = _r;
    i = _i;
  }
  friend Complex operator+(Complex u, Complex v) {
    return Complex(u.r + v.r, u.i + v.i);
  }
  friend Complex operator-(Complex u, Complex v) {
    return Complex(u.r - v.r, u.i - v.i);
  }
  friend Complex operator*(Complex u, Complex v) {
    return Complex(u.r * v.r - u.i * v.i, u.r * v.i + u.i * v.r);
  }
};
int R[MAXN * 4], L;
void FFT(Complex *y, int len, int on) {
  for (int i = 0; i < len; i++)
    if (i < R[i]) swap(y[i], y[R[i]]);
  for (int i = 1; i < len; i <<= 1) {
    Complex wn = Complex(cos(PI / i), sin(on * PI / i));
    for (int j = 0; j < len; j += (i << 1)) {
      Complex w = Complex(1, 0);
      for (int k = 0; k < i; k++, w = w * wn) {
        Complex u = y[j + k], v = y[j + k + i] * w;
        y[j + k] = u + v;
        y[j + k + i] = u - v;
      }
    }
  }
  if (on == -1)
    for (int i = 0; i < len; i++) y[i].r /= len;
}
void clear(Complex *a, int ln) {
  for (int i = 0; i < ln; i++) a[i] = Complex(0, 0);
}
int A[MAXN * 4], B[MAXN * 4], val[MAXN * 4];
void mul(int *a, int *b, int *ret, int n, int m) {
  static Complex A[MAXN * 4], B[MAXN * 4], C[MAXN * 4], D[MAXN * 4];
  static Complex A1[MAXN * 4], B1[MAXN * 4], C1[MAXN * 4];
  int ln = 1;
  L = 0;
  for (ln = 1; ln <= n + m - 1; ln <<= 1) ++L;
  for (int i = 0; i < ln; i++) R[i] = (R[i >> 1] >> 1) | (i & 1) << (L - 1);
  clear(A, ln);
  clear(B, ln);
  clear(C, ln);
  clear(D, ln);
  clear(A1, ln);
  clear(B1, ln);
  clear(C1, ln);
  for (int i = 0; i < n; i++)
    A[i] = Complex(a[i] / M, 0), B[i] = Complex(a[i] % M, 0);
  for (int i = 0; i < m; i++)
    C[i] = Complex(b[i] / M, 0), D[i] = Complex(b[i] % M, 0);
  FFT(A, ln, 1);
  FFT(B, ln, 1);
  FFT(C, ln, 1);
  FFT(D, ln, 1);
  for (int i = 0; i < ln; i++)
    A1[i] = A[i] * C[i], B1[i] = B[i] * C[i] + A[i] * D[i], C1[i] = B[i] * D[i];
  FFT(A1, ln, -1);
  FFT(B1, ln, -1);
  FFT(C1, ln, -1);
  for (int i = 0; i < n + m - 1; i++)
    A1[i].r = (long long)(A1[i].r + 0.5), B1[i].r = (long long)(B1[i].r + 0.5),
    C1[i].r = (long long)(C1[i].r + 0.5);
  for (int i = 0; i < n + m - 1; i++) {
    long long u = A1[i].r, v = B1[i].r, w = C1[i].r;
    u %= mod;
    v %= mod;
    w %= mod;
    ret[i] = (1LL * u * M % mod * M % mod + 1LL * v * M % mod + w) % mod;
  }
}
int main() {
  pre[0] = 1;
  for (int i = 1; i < MAXN * 4; i++) pre[i] = 1LL * pre[i - 1] * i % mod;
  inv[MAXN * 4 - 1] = pow_mod(pre[MAXN * 4 - 1], mod - 2);
  for (int i = MAXN * 4 - 2; i >= 0; i--)
    inv[i] = 1LL * inv[i + 1] * (i + 1) % mod;
  n = read();
  m = read();
  K = read();
  int ans = 0;
  for (int i = 0; i <= m; i++) A[i] = inv[i];
  for (int i = 0; i <= K; i++) B[i] = inv[i];
  mul(A, B, val, m + 1, K + 1);
  for (int i = 0; i <= m + K; i++)
    ad(ans, 1LL * pow_mod(3, m + K - i) * C(n + i - 1, i) % mod * val[i] % mod *
                pre[i] % mod);
  pr2(ans);
  return 0;
}
