#include <bits/stdc++.h>

using namespace std;

const int MOD = 1e9+7;

int64_t gcdExtended(int64_t a, int64_t b, int64_t* x, int64_t* y) { 
  if (a == 0) { 
    *x = 0, *y = 1; 
    return b; 
  } 
  int64_t x1, y1;
  int64_t gcd = gcdExtended(b % a, a, &x1, &y1); 
  *x = y1 - (b / a) * x1; 
  *y = x1;   
  return gcd; 
} 

int64_t modInverse(int64_t a) { 
  int64_t x, y; 
  gcdExtended(a, MOD, &x, &y); 
  return (x % MOD + MOD) % MOD; 
} 

int addmod(int x, int y) {
  int result = x+y;
  if (result >= MOD) {
    result -= MOD;
  }
  return result;
}

int multmod(int x, int y) {
  return (x * int64_t(y)) % MOD;
}

int addmodto(int& x, int y) {
  x += y;
  if (x >= MOD) {
    x -= MOD;
  }
  return x;
}

int solve_slow(int N, int M, int K) {
  vector<vector<int>> dp(N+M+1, vector<int>(N+1, 0));
  dp[0][0] = 1;
  for (int i = 1; i <= N+M; ++i) {
    for (int j = 0; j <= i; ++j) {
      if (j <= (i-j+K)) {
	dp[i][j] = dp[i-1][j];
	if (j > 0) {
	  addmodto(dp[i][j], dp[i-1][j-1]);
	}
      }
    }
  }
  return dp[N+M][N];
}

const int MAXVAL = 2e6;
int factorial[MAXVAL+1];

int choose(int n, int k) {
  if (n < k) {
    return 0;
  }
  return multmod(factorial[n], modInverse(multmod(factorial[n-k], factorial[k])));
}

int solve(int N, int M, int K) {
  if (N > (M+K)) {
    return 0;
  }
  return addmod(choose(N+M, N), MOD - choose(M+N, M+K+1));
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  factorial[0] = 1;
  for (int i = 1; i <= MAXVAL; ++i) {
    factorial[i] = multmod(factorial[i-1], i);
  }
  int N, M, K;
  cin >> N >> M >> K;
  cout << solve(N, M, K) << endl;
}

// execute g++ main.cpp -std=c++14 -I C:\Users\naoya\Desktop\code\Atcoder
#include<bits/stdc++.h>
//#include<atcoder/all>
typedef long long ll;
typedef long double ld;
using namespace std;
//using namespace atcoder;

using Pii = pair<int, int>;
using Pll = pair<ll, ll>;

//ordered_set 重複不可
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
template<typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
// use set_function + find_by_order(select itr-num)

#define REP(i, l, n) for(int i=(l), i##_len=(n); i<i##_len; ++i)
#define ALL(x) (x).begin(),(x).end()
#define pb push_back

ll gcd(ll a,ll b){return b ? gcd(b,a%b) : a;}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}

template<class T>inline bool chmax(T &a, T b) {if(a < b) {a = b;return true;}return false;}
template<class T>inline bool chmin(T &a, T b) {if(a > b) {a = b;return true;}return false;}


char alpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
char Alpha[26] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'};

int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, 1, -1};

//cout << std::fixed << std::setprecision(15) << y << endl; //小数表示

const ll MAX = 3000000; //テーブルの数
const ll MOD = 1e9+7; //mod宣言

long long fac[MAX], finv[MAX], inv[MAX];
// finv ->階乗割り算
// fac ->階乗掛け算

// テーブルを作る前処理
void COMinit() {
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算
long long COM(int n, int k){
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return (fac[n] * (finv[k] * finv[n - k] % MOD)) % MOD;
}

int main(){
    COMinit();
    ll n, m, k; cin >> n >> m >> k;
    if(n > m + k){
        cout << 0 << endl;
        return 0;
    }
    ll mid = 0;
    cout << (COM(n+m, n) + MOD - COM(n+m, m+k+1)) % MOD << endl;
}