#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
template <typename T>
T& chmin(T& a, const T& b) {
  return a = min(a, b);
}
template <typename T>
T& chmax(T& a, const T& b) {
  return a = max(a, b);
}
template <typename T>
T inf() {
  assert(false);
}
template <>
constexpr int inf<int>() {
  return 1e9;
}
template <>
constexpr ll inf<ll>() {
  return 1e18;
}
template <>
constexpr ld inf<ld>() {
  return 1e30;
}
const int mod = 1000000007;
struct Mod {
  int n;
  Mod() : n(0) { ; }
  Mod(int m) : n(m) {
    if (n >= mod)
      n %= mod;
    else if (n < 0)
      n = (n % mod + mod) % mod;
  }
  operator int() { return n; }
};
bool operator==(Mod a, Mod b) { return a.n == b.n; }
Mod operator+=(Mod& a, Mod b) {
  a.n += b.n;
  if (a.n >= mod) a.n -= mod;
  return a;
}
Mod operator-=(Mod& a, Mod b) {
  a.n -= b.n;
  if (a.n < 0) a.n += mod;
  return a;
}
Mod operator*=(Mod& a, Mod b) {
  a.n = ((long long)a.n * b.n) % mod;
  return a;
}
Mod operator+(Mod a, Mod b) { return a += b; }
Mod operator-(Mod a, Mod b) { return a -= b; }
Mod operator*(Mod a, Mod b) { return a *= b; }
Mod operator^(Mod a, int n) {
  if (n == 0) return Mod(1);
  Mod res = (a * a) ^ (n / 2);
  if (n % 2) res = res * a;
  return res;
}
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
Mod operator/(Mod a, Mod b) { return a * Mod(inv(b, mod)); }
Mod fact[1024000], factinv[1024000];
void init() {
  fact[0] = Mod(1);
  factinv[0] = 1;
  for (int i = 0; i < (int)(1024000 - 1); i++) {
    fact[i + 1] = fact[i] * Mod(i + 1);
    factinv[i + 1] = factinv[i] / Mod(i + 1);
  }
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }
const ld PI = acos(-1.0);
const int MOD = mod;
void addmod(int& x, int y, int mod) { (x += y) >= mod && (x -= mod); }
int mulmod(int x, int y, int mod) { return x * 1ll * y % mod; }
namespace FFT {
struct cd {
  ld a, b;
  cd(ld a, ld b) : a(a), b(b) {}
  cd(ld x = 0) : a(x), b(0) {}
  ld real() const { return a; }
  void operator+=(const cd& other) {
    a += other.a;
    b += other.b;
  }
  void operator-=(const cd& other) {
    a -= other.a;
    b -= other.b;
  }
  void operator*=(const cd& other) {
    tie(a, b) = make_pair(a * other.a - b * other.b, a * other.b + b * other.a);
  }
  friend cd operator*(const cd& x, const cd& y) {
    cd r = x;
    r *= y;
    return r;
  }
  friend cd operator+(const cd& x, const cd& y) {
    cd r = x;
    r += y;
    return r;
  }
  friend cd operator-(const cd& x, const cd& y) {
    cd r = x;
    r -= y;
    return r;
  }
  void operator/=(ld c) {
    a /= c;
    b /= c;
  }
};
const int LOG = 20;
const int N = 1 << LOG;
int rev[N];
cd root_[N];
inline cd root(int k, int n) { return root_[k * (N / n)]; }
void precalc() {
  rev[0] = 0;
  int hb = -1;
  for (int i = 1; i < N; ++i) {
    if ((i & (i - 1)) == 0) {
      ++hb;
    }
    rev[i] = rev[i ^ (1 << hb)] | (1 << (LOG - hb - 1));
  }
  for (int i = 0; i < (int)N; ++i) {
    ld ang = PI * i * 2.0 / N;
    root_[i] = cd(cosl(ang), sinl(ang));
  }
}
void fft_rec(cd* a, int n) {
  if (n == 1) {
    return;
  }
  fft_rec(a, n / 2);
  fft_rec(a + n / 2, n / 2);
  for (int k = 0; k < (int)n / 2; ++k) {
    cd w = root(k, n);
    cd x = a[k];
    cd y = w * a[k + n / 2];
    a[k] = x + y;
    a[k + n / 2] = x - y;
  }
}
void fft(vector<cd>& a) {
  int n = ((int)(a).size());
  vector<cd> na(n, cd(0, 0));
  for (int i = 0; i < (int)n; ++i) na[i] = a[rev[i]];
  na.swap(a);
  fft_rec(&a[0], n);
}
void fft_inv(vector<cd>& a) {
  fft(a);
  int n = ((int)(a).size());
  reverse(a.begin() + 1, a.end());
  for (int i = 0; i < (int)n; ++i) {
    a[i] /= n;
  }
}
vector<int> mult(const vector<int>& a, const vector<int>& b) {
  vector<cd> A(N, cd(0, 0));
  vector<cd> B(N, cd(0, 0));
  for (int i = 0; i < (int)((int)(a).size()); ++i) A[i] = a[i];
  for (int i = 0; i < (int)((int)(b).size()); ++i) B[i] = b[i];
  fft(A);
  fft(B);
  for (int i = 0; i < (int)N; ++i) A[i] *= B[i];
  fft_inv(A);
  vector<int> c(N, 0);
  for (int i = 0; i < (int)N; ++i) c[i] = ((ll)(A[i].real() + 0.5)) % MOD;
  return c;
}
vector<int> multmod(const vector<int>& a, const vector<int>& b) {
  int base = (int)sqrtl(MOD);
  vector<int> a0(((int)(a).size())), a1(((int)(a).size()));
  for (int i = 0; i < (int)((int)(a).size()); ++i) {
    a0[i] = a[i] % base;
    a1[i] = a[i] / base;
    assert(a[i] == a0[i] + base * a1[i]);
  }
  vector<int> b0(((int)(b).size())), b1(((int)(b).size()));
  for (int i = 0; i < (int)((int)(b).size()); ++i) {
    b0[i] = b[i] % base;
    b1[i] = b[i] / base;
    assert(b[i] == b0[i] + base * b1[i]);
  }
  vector<int> a01 = a0;
  for (int i = 0; i < (int)((int)(a).size()); ++i) {
    addmod(a01[i], a1[i], MOD);
  }
  vector<int> b01 = b0;
  for (int i = 0; i < (int)((int)(b).size()); ++i) {
    addmod(b01[i], b1[i], MOD);
  }
  vector<int> C = mult(a01, b01);
  vector<int> a0b0 = mult(a0, b0);
  vector<int> a1b1 = mult(a1, b1);
  vector<int> mid = C;
  for (int i = 0; i < (int)N; ++i) {
    addmod(mid[i], -a0b0[i] + MOD, MOD);
    addmod(mid[i], -a1b1[i] + MOD, MOD);
  }
  vector<int> res = a0b0;
  for (int i = 0; i < (int)N; ++i) {
    addmod(res[i], mulmod(base, mid[i], MOD), MOD);
  }
  base = mulmod(base, base, MOD);
  for (int i = 0; i < (int)N; ++i) {
    addmod(res[i], mulmod(base, a1b1[i], MOD), MOD);
  }
  return res;
}
};  // namespace FFT
Mod threes[1024000];
int main() {
  init();
  threes[0] = 1;
  for (int i = 0; i < (int)(1024000 - 1); i++)
    threes[i + 1] = threes[i] * Mod(3);
  int N, M, K;
  cin >> N >> M >> K;
  vector<int> invsj(1 << 20, 0), invsk(1 << 20, 0);
  for (int i = 0; i <= M; ++i) invsj[i] = factinv[i];
  for (int i = 0; i <= K; ++i) invsk[i] = factinv[i];
  FFT::precalc();
  vector<int> prod = FFT::multmod(invsj, invsk);
  Mod res = 0;
  for (int i = 0; i < (int)(M + K + 1); i++) {
    Mod val =
        fact[i + N - 1] * factinv[N - 1] * Mod(prod[i]) * threes[M + K - i];
    res += val;
  }
  cout << res << endl;
  return 0;
}
