def solution(arr):
    return all(arr[i] == arr[~i] for i in range(len(arr) // 2))

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