#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
#define ll long long
ll pwmd(ll a, ll n) {
    if(n == 0) return 1;
    ll tmp = pwmd(a, n / 2);
    tmp = (tmp * tmp) % MOD;
    return (n % 2 == 0 ? tmp : tmp * a % MOD);
}

int main() {
    ll n, m, k; cin >> n >> m >> k;
    vector<ll> fact(n + m + 2, 1);
    for(int i = 1;i < n + m + 2;++i) fact[i] = (fact[i - 1] * i) % MOD;
    if(n > m + k) {
        cout << 0 << '\n';
        return 0;
    }
    ll ans = fact[m + n] * pwmd(fact[m] * fact[n] % MOD, MOD - 2) % MOD;
    if(n == k) {
        cout << ans << '\n';
        return 0;
    }
    ans -= fact[m + n] * pwmd(fact[m + k + 1] * fact[n - k - 1] % MOD, MOD - 2) % MOD;
    ans %= MOD;
    ans = (ans + MOD) % MOD;
    cout << ans << '\n';
    return 0;
}
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define Pr pair<ll,ll>
#define Tp tuple<ll,ll,ll>
using Graph = vector<vector<int>>;

ll mod = 1000000007;

template< typename flow_t >
struct Dinic {
  const flow_t INF;

  struct edge {
    int to;
    flow_t cap;
    int rev;
    bool isrev;
    int idx;
  };

  vector< vector< edge > > graph;
  vector< int > min_cost, iter;

  Dinic(int V) : INF(numeric_limits< flow_t >::max()), graph(V) {}

  void add_edge(int from, int to, flow_t cap, int idx = -1) {
    graph[from].emplace_back((edge) {to, cap, (int) graph[to].size(), false, idx});
    graph[to].emplace_back((edge) {from, 0, (int) graph[from].size() - 1, true, idx});
  }

  bool bfs(int s, int t) {
    min_cost.assign(graph.size(), -1);
    queue< int > que;
    min_cost[s] = 0;
    que.push(s);
    while(!que.empty() && min_cost[t] == -1) {
      int p = que.front();
      que.pop();
      for(auto &e : graph[p]) {
        if(e.cap > 0 && min_cost[e.to] == -1) {
          min_cost[e.to] = min_cost[p] + 1;
          que.push(e.to);
        }
      }
    }
    return min_cost[t] != -1;
  }

  flow_t dfs(int idx, const int t, flow_t flow) {
    if(idx == t) return flow;
    for(int &i = iter[idx]; i < graph[idx].size(); i++) {
      edge &e = graph[idx][i];
      if(e.cap > 0 && min_cost[idx] < min_cost[e.to]) {
        flow_t d = dfs(e.to, t, min(flow, e.cap));
        if(d > 0) {
          e.cap -= d;
          graph[e.to][e.rev].cap += d;
          return d;
        }
      }
    }
    return 0;
  }

  flow_t max_flow(int s, int t) {
    flow_t flow = 0;
    while(bfs(s, t)) {
      iter.assign(graph.size(), 0);
      flow_t f = 0;
      while((f = dfs(s, t, INF)) > 0) flow += f;
    }
    return flow;
  }

  void output() {
    for(int i = 0; i < graph.size(); i++) {
      for(auto &e : graph[i]) {
        if(e.isrev) continue;
        auto &rev_e = graph[e.to][e.rev];
        cout << i << "->" << e.to << " (flow: " << rev_e.cap << "/" << e.cap + rev_e.cap << ")" << endl;
      }
    }
  }
};



//mod逆元
long long modinv(long long a, long long m) {
    long long b = m, u = 1, v = 0;
    while (b) {
        long long t = a / b;
        a -= t * b; swap(a, b);
        u -= t * v; swap(u, v);
    }
    u %= m;
    if (u < 0) u += m;
    return u;
}


//Combination2
//10^6くらいまで
//modはグローバルに定義しておく
vector<ll> fact;
vector<ll> invf;
ll comb(ll n,ll k){
    if(n<0||k<0||k>n) return 0LL;
    else{
        ll a = fact[n]*invf[k]%mod;
        a = a*invf[n-k]%mod;
        return a;
    }
}

int main() {

    ll B,W,K; cin >> W >> B >> K;
    if(W-B>=K+1){
        cout << 0 << endl; return 0;
    }
    //main関数内に以下ペースト
    //N:max
    ll N = B+W+2;
    fact.assign(N+1,1LL);
    invf.assign(N+1,1LL);
    rep(i,N) fact[i+1] = fact[i]*(i+1)%mod;
    rep(i,N+1) invf[i] = modinv(fact[i],mod);
    ll ans = (comb(B+W,B)+1000*mod-comb(B+W,B+K+1))%mod;
    if(K==W) ans = comb(B+W,B)%mod;
    
    cout << ans << endl;
}