#include <bits/stdc++.h>
using namespace std;
template <class C>
void mini(C& _a4, C _b4) {
  _a4 = min(_a4, _b4);
}
template <class C>
void maxi(C& _a4, C _b4) {
  _a4 = max(_a4, _b4);
}
template <class TH>
void _dbg(const char* sdbg, TH h) {
  cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char* sdbg, TH h, TA... a) {
  while (*sdbg != ',') cerr << *sdbg++;
  cerr << '=' << h << ',';
  _dbg(sdbg + 1, a...);
}
template <class T>
ostream& operator<<(ostream& os, vector<T> V) {
  os << "[";
  for (auto& vv : V) os << vv << ",";
  os << "]";
  return os;
}
const long double kPi = 2 * acos(0);
struct CD {
  long double re, im;
  CD operator=(long double a) {
    re = a;
    im = 0;
    return *this;
  }
  CD operator*(CD& z) { return {re * z.re - im * z.im, re * z.im + im * z.re}; }
  void operator*=(CD& z) { *this = (*this * z); }
  CD operator+(CD& z) { return {re + z.re, im + z.im}; }
  CD operator-(CD& z) { return {re - z.re, im - z.im}; }
  void operator/=(long double f) {
    re /= f;
    im /= f;
  }
};
struct FFT {
 private:
  CD *A, *B, *tmp, *res, *omega;
  long long* rev_perm;
  long long max_dep;
  void Clear(long long n) {
    for (long long i = (0); i <= ((long long)(n)-1); i++) {
      A[i] = B[i] = res[i] = tmp[i] = 0;
    }
  }
  void fft(CD* from, CD* to, long long depth, bool inv) {
    long long N = (1 << depth);
    for (long long i = (0); i <= ((long long)(N)-1); i++) {
      to[rev_perm[i] >> (max_dep - depth)] = from[i];
    }
    for (long long m = (1); m <= (depth); m++) {
      long long step = (1 << m);
      for (long long pos = 0; pos < N; pos += step) {
        long long cur = 0;
        long long delta = (1 << (max_dep - m));
        if (!inv) {
          cur = (1 << max_dep);
          delta *= -1;
        }
        for (long long k = (0); k <= ((long long)(step / 2) - 1); k++) {
          CD a = to[pos + k], b = omega[cur] * to[pos + k + step / 2];
          to[pos + k] = a + b;
          to[pos + k + step / 2] = a - b;
          cur += delta;
        }
      }
    }
    if (inv) {
      for (long long i = (0); i <= ((long long)(N)-1); i++) {
        to[i] /= N;
      }
    }
  }

 public:
  FFT(long long max_deg) {
    max_dep = 0;
    while ((1 << max_dep) <= 2 * max_deg) {
      max_dep++;
    }
    max_deg = (1 << max_dep) + 20;
    A = new CD[max_deg];
    B = new CD[max_deg];
    res = new CD[max_deg];
    tmp = new CD[max_deg];
    omega = new CD[max_deg];
    rev_perm = new long long[max_deg];
    long long N = (1 << max_dep);
    long double ang = 2 * kPi / N;
    for (long long i = (0); i <= ((long long)(N + 1) - 1); i++) {
      omega[i] = {cos(i * ang), sin(i * ang)};
    }
    rev_perm[0] = 0;
    long long h = -1;
    for (long long i = (1); i <= (N); i++) {
      if ((i & (i - 1)) == 0) {
        h++;
      }
      rev_perm[i] = rev_perm[i ^ (1 << h)] | (1 << (max_dep - h - 1));
    }
  }
  vector<long long> mul_less_exact(vector<long long> Q, vector<long long> R,
                                   long long P) {
    long long depth = 0, size = 1;
    long long N = ((long long)(Q).size()) + ((long long)(R).size()) - 1;
    while (size < N) {
      depth++;
      size *= 2;
    }
    Clear(size);
    for (long long i = (0); i <= ((long long)(((long long)(Q).size())) - 1);
         i++)
      A[i] = CD{.5 * Q[i] + .5 * R[i], .5 * Q[i] - .5 * R[i]};
    fft(A, tmp, depth, false);
    for (long long i = (0); i <= ((long long)(size)-1); i++) tmp[i] *= tmp[i];
    fft(tmp, res, depth, true);
    vector<long long> ans;
    for (long long i = (0); i <= ((long long)(N)-1); i++) {
      ans.push_back((long long)round(res[i].re) % P);
    }
    return ans;
  }
  vector<long long> Prepare(vector<long long>& v, long long base,
                            long long b_pow) {
    vector<long long> ans;
    for (long long x : v) {
      ans.push_back(b_pow ? x / base : x % base);
    }
    return ans;
  }
  long long Sum(vector<long long>& v, long long P) {
    return accumulate((v).begin(), (v).end(), 0LL) % P;
  }
  vector<long long> mul_exact(vector<long long> Q, vector<long long> R,
                              long long P) {
    long long base = 32000;
    long long pows[] = {1, base, (long long)1LL * base * base % P};
    vector<long long> ans(((long long)(Q).size()) + ((long long)(R).size()) -
                          1);
    for (long long q = (0); q <= ((long long)(2) - 1); q++) {
      vector<long long> W = Prepare(Q, base, q);
      for (long long r = (0); r <= ((long long)(2) - 1); r++) {
        vector<long long> V = Prepare(R, base, r);
        vector<long long> C = mul_less_exact(W, V, P);
        for (long long i = (0); i <= ((long long)(((long long)(C).size())) - 1);
             i++) {
          ans[i] = (ans[i] + 1LL * C[i] * pows[q + r]) % P;
        }
      }
    }
    (Sum(ans, P), 1LL * Sum(Q, P) * Sum(R, P) % P);
    assert(Sum(ans, P) == 1LL * Sum(Q, P) * Sum(R, P) % P);
    return ans;
  }
};
long long P = 1e9 + 7;
long long pot(long long a, long long w) {
  long long r = 1;
  while (w) {
    if (w & 1) r = r * a % P;
    w /= 2;
    a = a * a % P;
  }
  return r;
}
long long odw(long long a) { return pot(a, P - 2); }
const long long MAX = 1e6;
long long sil[MAX];
long long a, b, c;
FFT fft((long long)(3e5) + 2);
int32_t main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(11);
  if (0) cout << fixed << setprecision(6);
  sil[0] = 1;
  for (long long i = 1; i < MAX; i++) sil[i] = sil[i - 1] * i % P;
  cin >> a >> b >> c;
  vector<long long> x, y;
  for (long long i = (0); i <= ((long long)(b + 1) - 1); i++) {
    x.push_back(odw(sil[b - i]));
  }
  for (long long i = (0); i <= ((long long)(c + 1) - 1); i++) {
    y.push_back(odw(sil[c - i]));
  }
  (x, y);
  vector<long long> spl = fft.mul_exact(x, y, P);
  (spl);
  long long res = 0;
  long long mn = odw(sil[a - 1]);
  for (long long i = (0); i <= ((long long)(((long long)(spl).size())) - 1);
       i++) {
    (sil[a - 1 + b + c - i], mn, spl[i]);
    res += sil[a - 1 + b + c - i] * mn % P * spl[i] % P;
    (res);
    mn *= 3;
    mn %= P;
  }
  cout << res % P << endl;
}
