#include<bits/stdc++.h>
#define XX first
#define YY second
#define pb emplace_back
#define FOR(i,a,b) for(int (i)=(a);i<(b);++(i))
#define EFOR(i,a,b) for(int (i)=(a);i<=(b);++(i))
#define rep(X,Y) for (int (X) = 0;(X) < (Y);++(X))
#define REP rep
#define rrep(X,Y) for (int (X) = (Y)-1;(X) >=0;--(X))
#define all(X) (X).begin(),(X).end()
#define eb emplace_back

using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef ll LL;
typedef pii PII;
typedef pll PLL;
const ll MOD=1e9+7;

#define rall(X) (X).rbegin(),(X).rend()
#define UNIQUE(X) (X).erase(unique(all(X)),(X).end())
#define reps(X,S,Y) for (int (X) = S;(X) < (Y);++(X))
#define rreps(X,S,Y) for (int (X) = (Y)-1;(X) >= (S);--(X))
template<class T> inline bool MX(T &l,const T &r){return l<r?l=r,1:0;}
template<class T> inline bool MN(T &l,const T &r){return l>r?l=r,1:0;}


using C = complex<double>;
namespace std {
  template<>
  C& C::operator*=(const C& y) {
    double a = this->real();
    double b = this->imag();
    double c = y.real();
    double d = y.imag();
    return *this=C(a*c-b*d, a*d+b*c);
  }
}

template<int B> // n <= 1<<B
struct FFT{
  vector<int> m2[B+1];
  vector<C> power[B+1];

  FFT(){
    rep(e, B+1){
      int lim = 1 << e;
      m2[e].resize(lim);
      power[e].resize(lim);
      rep(st, lim) power[e][st] = polar(1.0, M_PI*st/lim);
      rep(i, e) rep(st, lim) if(st >> i & 1) m2[e][st] |= 1 << e-1-i;
    }
  }

  void Dft(C *f, int lim) {
    int e = 31 - __builtin_clz(lim);
    assert(e <= B);
    assert(1 << e == lim);
    rep(st, lim) if(st < m2[e][st]) swap(f[st], f[m2[e][st]]);

    rep(k, e) {
      int t = 1 << k;
      int w = 1 << k+1;
      C *po = power[k].data();
      for (int i=0; i<lim; i+=w) {
        rep(j, t) {
          C x = f[i+j];
          C y = f[i+j+t] * po[j];
          f[i+j] = x + y;
          f[i+j+t] = x - y;
        }
      }
    }
  }

  template <class T>
  vector<C> Conv(vector<T> &f, vector<T> &g) {
    int n = f.size() + g.size() - 1;
    int lim = 2;
    while (lim < n) lim <<= 1;
    vector<C> cf(all(f));
    vector<C> cg(all(g));
    cf.resize(lim);
    cg.resize(lim);
    Dft(cf.data(), lim);
    Dft(cg.data(), lim);
    rep(i, lim) cf[i] = conj(cf[i] * cg[i])/double(lim);
    Dft(cf.data(), lim);
    // DO conj one more if you put complex numbers !!!
    cf.resize(n);
    return cf;
  }

  vector<LL> Conv2(vector<LL> &f, vector<LL> &g, LL mod) {
    int n = f.size();
    int m = g.size();
    int lim = 2;
    while (lim < n+m) lim <<= 1;

    const int D = 3;
    const int L = 10;
    const int M = (1 << L) - 1;
    vector<C> cs[D];
    vector<C> ds[D];
    vector<C> es[D];
    rep(i, D) {
      cs[i].resize(lim+10);
      ds[i].resize(lim+10);
      es[i].resize(lim+10);
      rep(j, n) es[i][j].real(f[j] >> (i*L) & M);
      rep(j, m) es[i][j].imag(g[j] >> (i*L) & M);
      Dft(es[i].data(), lim);
      rep(j, lim) {
        int nj = (lim-j) & (lim-1);
        cs[i][j] = es[i][j] + conj(es[i][nj]);
        ds[i][j] = es[i][j] - conj(es[i][nj]);
      }
      es[i].assign(lim, C());
    }

    rep(i, D) {
      rep(j, D) {
        rep(k, lim) {
          int r = (i+j) >> 1;
          int m = (i+j) % 2;
          es[r][k] += cs[i][k] * ds[j][k] * polar(0.25, (m-1) * M_PI/2);
        }
      }
    }

    rep(i, D) {
      rep(j, lim) es[i][j] = conj(es[i][j])/double(lim);
      Dft(es[i].data(), lim);
    }

    vector<LL> ret(n+m-1);
    rep(j, ret.size()) {
      LL mul = 1;
      rep(i, D*2-1) {
        LL v;
        if (i%2) {
          v = llround(-es[i/2][j].imag()) % mod;
        } else {
          v = llround(es[i/2][j].real()) % mod;
        }
        ret[j] += v * mul;
        ret[j] %= mod;
        mul <<= L;
        mul %= mod;
      }
    }
    return ret;
  }
};
FFT<20> fft;

// [1, N] の法Pによる逆元をO(N)で列挙
vector<LL> CalcModInvs(int n, LL p) {
  vector<LL> inv(n+1);
  inv[1]=1;
  reps(i, 2, n+1) inv[i] = (p-(p/i*inv[p%i])%p)%p;
  return inv;
}

int N, M, K;
LL finv[314514];
LL pw3[1145141];
LL fact[1145141];

signed main(){
  ios_base::sync_with_stdio(false);
  cout<<fixed<<setprecision(0);

  auto invs = CalcModInvs(314514, MOD);
  pw3[0] = fact[0] = 1;
  reps(i, 1, 1145141) {
    fact[i] = fact[i-1]*i % MOD;
    pw3[i] = pw3[i-1]*3 % MOD;
  }
  finv[0] = 1;
  reps(i, 1, 314514) {
    finv[i] = finv[i-1]*invs[i] % MOD;
  }

  cin >> N >> M >> K;
  vector<LL> A(M+1);
  vector<LL> B(K+1);
  rep(i, M+1) {
    A[i] = finv[i];
  }
  rep(i, K+1) {
    B[i] = finv[i];
  }

  auto C = fft.Conv2(A, B, MOD);
  LL ans = 0;
  rep(S, M+K+1) {
    ans += pw3[M+K-S] * fact[N-1+S] % MOD * finv[N-1] % MOD * C[S];
    ans %= MOD;
  }
  cout << ans << endl;
}


Measured memory_bytes: 220928