#include <bits/stdc++.h>

/* -------------------------------- Template -------------------------------- */

#define REP(i,n) for(int i=0;i<(int)(n);i++)
#define ALL(x) (x).begin(),(x).end()

using namespace std;

using ll = long long;
using ld = double;
// 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; }

/* -------------------------------- Library -------------------------------- */

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)); }

#define MAX_N 1024000

Mod fact[MAX_N], factinv[MAX_N];
void init() {
  fact[0] = Mod(1); factinv[0] = 1;
  REP(i,MAX_N-1) {
    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];
}

// http://www.everfall.com/paste/id.php?9kb9dxwtbmah
// pakutte kita.

#define mp make_pair
#define sz(C) ((int) (C).size())
#define forn(i, n) for (int i = 0; i < (int) n; ++i)

typedef vector <int> vi;

const ld PI = acos(-1.0);
const ll 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) = mp(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;
    }
  };

  typedef vector<cd> vcd;

  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));
    }

    forn(i, N) {
      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);

    forn(k, n / 2) {
      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(vcd& a) {
    int n = sz(a);
    vcd na(n, cd(0, 0));
    forn(i, n) na[i] = a[rev[i]];
    na.swap(a);

    fft_rec(&a[0], n);
  }

  void fft_inv(vcd& a) {
    fft(a);
    int n = sz(a);
    reverse(a.begin() + 1, a.end());
    forn(i, n) {
      a[i] /= n;
    }
  }

  vi mult(const vi& a, const vi& b) {
    //    TimeStamp t("mult");
    vcd A(N, cd(0, 0));
    vcd B(N, cd(0, 0));
    forn(i, sz(a)) A[i] = a[i];
    forn(i, sz(b)) B[i] = b[i];

    fft(A);
    fft(B);

    forn(i, N) A[i] *= B[i];

    fft_inv(A);

    vi c(N, 0);
    forn(i, N) c[i] = ((ll) (A[i].real() + 0.5)) % MOD;

    return c;
  }

  vi multmod(const vi& a, const vi& b) {
    // a = a0 + sqrt(MOD) * a1
    // a = a0 + base * a1
    int base = (int) sqrtl(MOD);

    vi a0(sz(a)), a1(sz(a));
    forn(i, sz(a)) {
      a0[i] = a[i] % base;
      a1[i] = a[i] / base;
      assert(a[i] == a0[i] + base * a1[i]);
    }

    vi b0(sz(b)), b1(sz(b));
    forn(i, sz(b)) {
      b0[i] = b[i] % base;
      b1[i] = b[i] / base;
      assert(b[i] == b0[i] + base * b1[i]);
    }

    vi a01 = a0;
    forn(i, sz(a)) {
      addmod(a01[i], a1[i], MOD);
    }

    vi b01 = b0;
    forn(i, sz(b)) {
      addmod(b01[i], b1[i], MOD);
    }

    vi C = mult(a01, b01);  // 1

    vi a0b0 = mult(a0, b0); // 2
    vi a1b1 = mult(a1, b1); // 3

    vi mid = C;
    forn(i, N) {
      addmod(mid[i], -a0b0[i] + MOD, MOD);
      addmod(mid[i], -a1b1[i] + MOD, MOD);
    }

    vi res = a0b0;
    forn(i, N) {
      addmod(res[i], mulmod(base, mid[i], MOD), MOD);
    }

    base = mulmod(base, base, MOD);
    forn(i, N) {
      addmod(res[i], mulmod(base, a1b1[i], MOD), MOD);
    }

    return res;
  }
};

/* ---------------------------------- Main ---------------------------------- */

Mod threes[MAX_N];

int main() {
  init();
  threes[0] = 1;
  REP(i,MAX_N-1) threes[i+1] = threes[i] * Mod(3);
  int N, M, K;
  cin >> N >> M >> K;

  vector<int> invsj(650000, 0), invsk(650000, 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();
  // cout << invsj.size() << endl;
  // cout << invsk.size() << endl;
  vector<int> prod = FFT::multmod(invsj, invsk);
  // cout << prod.size() << endl;
  // REP(i,20) cout << prod[i] << " "; cout << endl;
  // REP(i,20) cout << invsj[i] << " "; cout << endl;
  // REP(i,20) cout << invsk[i] << " "; cout << endl;

  Mod res = 0;
  REP(i,M+K+1) {
    Mod val = fact[i+N-1] * factinv[N-1] * Mod(prod[i])
      * threes[M+K-i];
    res += val;
  }
  cout << res << endl;
  return 0;
}


Measured memory_bytes: 110452