def solution(n, t, edges):
    graph = [[] for _ in range(n)]
    for u, v in edges:
        graph[u].append(v)
        graph[v].append(u)
    
    def dfs(node, parent):
        size, time_sum = 1, 0
        for child in graph[node]:
            if child != parent:
                c_size, c_time = dfs(child, node)
                size += c_size
                time_sum += c_time + t[child] * c_size
        return size, time_sum
    
    total_time = sum(t)
    expected_times = [0] * n
    
    def calculate_expected(node, parent, parent_contrib):
        size, time_sum = dfs(node, parent)
        expected_times[node] = t[node] + (time_sum + parent_contrib) / (n - 1)
        for child in graph[node]:
            if child != parent:
                child_contrib = parent_contrib + (total_time - time_sum - t[child]) * (n - size)
                calculate_expected(child, node, child_contrib / (n - 1))
    
    calculate_expected(0, -1, 0)
    return min(range(n), key=lambda i: expected_times[i])

#include <vector>
#include <iostream>
using namespace std;
int solve(vector<vector<int>>& operations) {
    const int MAX_N = 100001;
    vector<int> diff(MAX_N + 1, 0);
    for (const auto& op : operations) {
        int l = op[0];
        int r = op[1];
        diff[l] += 1;
        if (r + 1 <= MAX_N) {
            diff[r + 1] -= 1;
        }
    }
    int sum = 0;
    int aa = 0;
    for (int i = 1; i <= MAX_N; ++i) {
        aa += diff[i];
        if (aa % 2 != 0) {
            sum += i;
        }
    }

    return sum;
}

MOD = 10**9 + 7

def factorial(n, mod):
    result = 1
    for i in range(2, n + 1):
        result = (result * i) % mod
    return result

def mod_inv(a, p):
    return pow(a, p - 2, p)

def comb(n, k, mod):
    if k > n:
        return 0
    numerator = factorial(n, mod)
    denominator = (factorial(k, mod) * factorial(n - k, mod)) % mod
    return (numerator * mod_inv(denominator, mod)) % mod

def count_ways(N, C, V):
    if V > C:
        return 0
    total_ways = 0
    for i in range(V, C + 1):
        total_ways = (total_ways + comb(C, i, MOD)) % MOD
    return total_ways

N, C, V = map(int, input().split())
print(count_ways(N, C, V))

#include <iostream>
#include <unordered_map>
#include <string>
string solve(const std::string &s) {
unordered_map<char, char> charValueMap = {
        {'a', '0'}, {'b', '0'}, {'c', '0'}, {'d', '0'}, {'e', '0'},
        {'f', '1'}, {'g', '1'}, {'h', '1'}, {'i', '1'}, {'j', '1'},
        {'k', '0'}, {'l', '0'}, {'m', '0'}, {'n', '0'}, {'o', '0'},
        {'p', '1'}, {'q', '1'}, {'r', '1'}, {'s', '1'}, {'t', '1'},
        {'u', '0'}, {'v', '0'}, {'w', '0'}, {'x', '0'}, {'y', '0'},
        {'z', '1'}
    };

    std::string binaryString;
    for (char ch : s) {
        binaryString += charValueMap[ch];
    }

    return binaryString;
}

int main() {
   string inputString;
getline(std::cin, inputString); 

   string result = solve(inputString);
    
  cout << result << std::endl; 

    return 0;
}

def findParent(processNumber):
    if processNumber == 1:
        return None

    left, right = 1, processNumber

    while left < right:
        mid = (left + right) // 2
        children_up_to_mid = mid * (mid + 1) // 2
        
        if children_up_to_mid < processNumber:
            left = mid + 1
        else:
            right = mid

    parent = left
    children_up_to_parent = parent * (parent + 1) // 2

    return parent if children_up_to_parent >= processNumber else parent - 1

#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100000;
vector<int> tree[MAXN];
vector<int> prefixSum;
vector<int> cost;
vector<int> parent;
int N, K;
void dfs(int node, int par, int currentSum) {
    prefixSum[node] = currentSum + cost[node];
    parent[node] = par;
    for (int child : tree[node]) {
        if (child != par) {
            dfs(child, node, prefixSum[node]);
        }
    }
}
int solve(int N, int K, vector<int>& A, vector<vector<int>>& edges) {
    cost = A;
    prefixSum.assign(N, 0);
    parent.assign(N, -1);
    
    for (int i = 0; i < N; ++i) {
        tree[i].clear();
    }
    
    for (auto& edge : edges) {
        int u = edge[0] - 1;
        int v = edge[1] - 1;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    dfs(0, -1, 0);
    int maxCandies = 0;
    for (int i = 0; i < N; ++i) {
        int remainingMoney = K;
        int candies = 0;
        for (int j = i; j != -1; j = parent[j]) {
            if (remainingMoney >= cost[j]) {
                remainingMoney -= cost[j];
                candies++;
            } else {
                break;
            }
        }
        maxCandies = max(maxCandies, candies);
    }

    return maxCandies;
}

#include <iostream>
#include <vector>
#include <queue>
#include <unordered_map>
using namespace std;
int solve(int N, int K, const vector<int>& houses) {
    unordered_map<int, int> houseIndex;
    for (int i = 0; i < houses.size(); ++i) {
        houseIndex[houses[i] - 1] = i + 1;
    }

    priority_queue<int> pq;
    for (int i = 0; i < K; ++i) {
        pq.push(houseIndex[i]);
    }

    int ans = pq.top();
    for (int i = 1; i + K - 1 < N; ++i) {
        pq.push(houseIndex[i + K - 1]);
        while (!pq.empty() && pq.top() > houseIndex[i + K - 1]) {
            pq.pop();
        }
        ans = min(ans, pq.top());
    }

    return ans;
}

#include <iostream>
#include <vector>
#include <stack>
using namespace std;
vector<int> smallestLexicographicalSubsequence(vector<int>& hubs, int k) {
    vector<int> result;
    stack<int> st;
    int n = hubs.size();

    for (int i = 0; i < n; ++i) {
        while (!st.empty() && st.top() > hubs[i] && st.size() + (n - i) > k) {
            st.pop();
        }
        if (st.size() < k) {
            st.push(hubs[i]);
        }
    }
        while (!st.empty()) {
        result.insert(result.begin(), st.top());
        st.pop();
    }
    
    return result;
}