//
// Created by codicon on 3/9/2023 at 6:56 PM.
//

// O(n^5/2^2)

// The idea is that there is a bijection between the n + 1prefix sums and the n values of the array

#include <bits/stdc++.h>

using namespace std;

# define add(a, b) a = ((a) + (b)) % MOD;

int n, k, t;

const int MAXN = 64, MOD =  998'244'353;

int dp[MAXN + 1][MAXN + 2][(MAXN)*(MAXN+1)/2 + 1];

long long FAC[MAXN+2], INV_FAC[MAXN+2];
long long ch[MAXN+1][MAXN+1];

long long binexp(long long b, int e) {
    long long res = 1;

    for (; e; b = b * b % MOD, e >>= 1) {
        if (e&1) res = res * b % MOD;
    }

    return res;
}

long long choose(int n, int k) {
    if (k > n) {
        return 0;
    }

    return (FAC[n] * INV_FAC[k] % MOD) * INV_FAC[n-k] % MOD;
}

void set_up() {
    FAC[0] = 1;
    for (int i = 1; i <= MAXN+1; i++) {
        FAC[i] = FAC[i-1] * i % MOD;
    }

    INV_FAC[MAXN+1] = binexp(FAC[MAXN+1], MOD-2);
    for (int i = MAXN; i >= 0; i--) {
        INV_FAC[i] = INV_FAC[i+1] * (i+1) % MOD;
    }

    for (int n = 0; n <= MAXN+1; n++) {
        for (int k = 0; k <= MAXN+1; k++) {
            ch[n][k] = choose(n, k);
        }
    }
}

int main() {
    cin.tie(0)->sync_with_stdio(0);

    cin >> n >> k >> t;

    set_up();

    // Base case
    for (int used = 1; used <= n+1; used++) {
        dp[1][used][ch[used][2]] = 1;
    }

    // Do dp
    for (int pused = 1; pused < k; pused++) {
        for (int used = 1; used <= n+1; used++) {
            for (int goodness = 0; goodness <= t; goodness++) {
                // Don't use prefix value
                add(dp[pused + 1][used][goodness], dp[pused][used][goodness])

                // Use prefix value
                for (int new_used = 1;
                     new_used + used <= n+1 and
                     goodness + ch[new_used][2] <= t;
                     new_used++) {
                    add(dp[pused + 1][used + new_used][goodness + ch[new_used][2]],
                        dp[pused][used][goodness] * ch[used-1 + new_used][new_used] % MOD)
                }
            }
        }
    }

    cout << dp[k][n+1][t];
}