#include <bits/stdc++.h>
using namespace std;

long long n, k, m;
long long dp[1000007]; // dp[i]: số cách đặt sỏi vào các ô từ 1 đến i

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    freopen("bai2.inp", "r", stdin);
    freopen("bai2.out", "w", stdout);

    cin >> n >> k >> m;

    // Base case: không đặt viên sỏi nào
    // Tuy nhiên, ta cần xử lý cho k viên sỏi

    // Ý tư: dp[i][j] là số cách đặt j viên sỏi vào i ô
    vector<vector<long long>> dp(m + 1, vector<long long>(k + 1, 0));

    // Không đặt viên sỏi nào
    for (int i = 0; i <= m; i++) dp[i][0] = 1;

    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= k; j++) {
            // Nếu ô i không có sỏi
            dp[i][j] = dp[i-1][j];
            // Nếu ô i có sỏi (đặt viên thứ j vào ô i)
            // thì các ô i-1, i-2, ..., i-n+1 phải trống
            // Ta phải lấy từ ô i-n
            if (i > n) dp[i][j] += dp[i-n][j-1];
            else if (i == n || i == 1) dp[i][j] += 1; // Đặt viên sỏi đầu tiên
            else dp[i][j] += dp[0][j-1];
        }
    }

    cout << dp[m][k];
    return 0;
}

#include <bits/stdc++.h>
#define int long long
using namespace std;

const int N = 1e6 + 5;
int dp[N]; // dp[j]: số cách đặt sỏi vào j ô
int n, k, m;

void solve() {
    freopen("bai2.inp", "r", stdin);
    freopen("bai2.out", "w", stdout);
    cin >> n >> k >> m;

    // Base case: không có sỏi
    // Tuy nhiên, ta cần tính toán theo số lượng sỏi
    // Solution 1 và 2 cho thấy cách tính lũy kế

    // Giả sử ta dùng mảng 1D:
    // dp[i] = số cách đặt sỏi vào i ô với 1 viên sỏi
    // Công thức tổng quát: số cách đặt j viên sỏi

    // Dựa trên Solution 1:
    // Dp[i][j]: số cách đặt j viên sỏi vào i ô
    // Dp[i][1] = Dp[i-1][1] + 1 (nếu i >= 1)
    // Dp[i][2] = Dp[i-1][2] + Dp[i-n][1]

    // Code tối ưu:
    vector<int> dp(m + 1, 0);
    dp[0] = 1; // 1 cách để không đặt gì

    // Tính cho 1 viên sỏi
    for (int i = 1; i <= m; i++) {
        if (i >= n) dp[i] = dp[i-n] + dp[i-1];
        else dp[i] = dp[i-1] + 1;
    }

    // Tính cho k viên sỏi
    for (int t = 2; t <= k; t++) {
        vector<int> new_dp(m + 1, 0);
        for (int i = 1; i <= m; i++) {
            new_dp[i] = new_dp[i-1] + dp[i-n];
        }
        dp = new_dp;
    }

    cout << dp[m];
}

main() {
    solve();
    return 0;
}

#include <bits/stdc++.h>
#define int long long
using namespace std;

main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    freopen("bai2.inp", "r", stdin);
    freopen("bai2.out", "w", stdout);

    int n, k, m;
    cin >> n >> k >> m;

    // Solution 2 & 3 cho thấy cách tính lũy kế
    // dp[i] = số cách đặt sỏi vào i ô
    // Bắt đầu với 1 viên sỏi

    vector<int> dp(m + 1, 0);
    dp[1] = 1;
    if (m >= 2) dp[2] = 1;

    // Tính lũy kế cho 1 viên sỏi
    int sum = dp[1] + dp[2];
    for (int i = 3; i <= m; i++) {
        dp[i] = sum;
        sum += dp[i];
    }

    // Với k viên sỏi, ta lặp lại quá trình
    // Tăng dp[1], dp[2] thêm 1 mỗi lần thêm sỏi
    // Tính tổng mới cho các ô tiếp theo

    int current_sum;
    for (int t = 2; t <= k; t++) {
        dp[1]++;
        dp[2]++;
        current_sum = dp[1] + dp[2];
        for (int i = 3; i <= m; i++) {
            dp[i] = current_sum;
            current_sum += dp[i];
        }
    }

    cout << dp[m];
    return 0;
}