#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
#define per(i,n) for(int i=(n)-1;i>=0;i--)
#define rep1(i,n) for(int i=1;i<=(n);i++)
#define per1(i,n) for(int i=(n);i>=1;i--)
#define repk(i,a,b) for(int i=(a);i<=(b);i++)
#define perk(i,a,b) for(int i=(a);i>=(b);i--)
#define rep0(i,a,b) for(int i=(a);i<(b);i++)
#define pb push_back
#define mp make_pair
#define g(x) cout<<#x<<'='<<x<<endl
#define nextp next_permutation
#define pq priority_queue
#define fi first
#define se second
typedef long long ll;
using namespace std;
const ll mod1=998244353;
const ll mod2=1000000007;
//long long , 特判
//ios_base::sync_with_stdio(false);加快cin
long long f(long long a)
{
	long long res=1;
	for(int i=1;i<=a;++i)
	{
		res=res*i%mod2;
	}
	return res;
}
long long qkpw(long long a,long long b)
{
	long long res=1;
	while(b)
	{
		if(b&1) res=res*a%mod2;
		a=a*a%mod2;
		b>>=1;
	}
	return res;
}
long long inv(long long a)
{
	return qkpw(a,mod2-2);
}
long long c(long long n,long long m)
{
	if(n<m) return 0;
	return f(n)*inv(f(m)*f(n-m)%mod2)%mod2;
}
long long n,m,k;
int main()
{
	cin>>n>>m>>k;
	if(n>m+k) cout<<0<<endl; 
	else cout<<(c(n+m,n)-c(n+m,k+m+1)+mod2)%mod2<<endl;
	return 0;
}
#include <cctype>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <ios>
#include <iostream>
#include <iterator>
#include <string_view>
#include <utility>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <climits>
#include <cmath>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <regex>
#include <set>
#include <bitset>
#include <list>

const int64_t infl = 1LL << 60;
const int64_t cc = pow(10, 9) + 7;
bool sort_pair(std::pair<int64_t, char> origin,
               std::pair<int64_t, int64_t> another) {
  return origin.first < another.first;
}
bool sort_pair2(std::pair<int64_t, char> origin,
               std::pair<int64_t, int64_t> another) {
  return origin.second < another.second;
}

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

//繰り返し二乗法
int64_t RepeatSquaring( int64_t n, int64_t p, int64_t mod )
{
    if( p == 0 )
    {
        return 1;
    }

    if( p % 2 == 0 )
    {
        int64_t t = RepeatSquaring( n, p / 2, mod );
        return t * t % mod;
    }

    return n * RepeatSquaring( n, p - 1, mod ) % mod;
}

//フェルマーの小定理を利用するのでmodが素数の時のみ
int64_t waru_mod( int64_t a, int64_t b, int64_t mod )
{
    b = RepeatSquaring( b, mod - 2, mod ) % mod;
    return  ( a * b ) % mod;
}

//コンビネーションをmodで割った余りを産出
int64_t nCk( int64_t n, int64_t k, int64_t mod )
{
    int64_t ans_x = 1;
    int64_t ans_y = 1;

    for( int i = n; i > n - k; i-- )
    {
        ans_x *= i;
        ans_x %= mod;
    }

    for( int i = 1; i <= k; i++ )
    {
        ans_y *= i;
        ans_y %= mod;
    }

    return waru_mod( ans_x, ans_y, mod );
}

int main()
{
    int64_t q,k,h,w,d,m,n;
    std::cin>> n;
    std::cin>> m;
    std::cin>> k;

    if( k + m < n )
    {
        std::cout<< 0;
    }
    else
    {
        q = nCk( n + m, n, cc );

        if( n - k - 1 < 0 )
        {
            h = 0;
        }
        else
        {
            h = nCk( n + m, n - k - 1, cc );
        }
        
        q -= h;
        q %= cc;

        
        if( q < 0 ) q += cc;

        std::cout<< q;
    }
}

