#include <bits/stdc++.h>

using namespace std;

const int N = 105, LIM = 1e6, P = 998244353, G = 3, iG = (P + 1) / G;

int inv[LIM + 5];

int ksm(int x, int y = P - 2)
{
    if (x <= LIM && y == P - 2) {
        return inv[x];
    }
    int res = 1;
    while (y) {
        if (y & 1) {
            res = 1ll * res * x % P;
        }
        x = 1ll * x * x % P;
        y >>= 1;
    }
    return res;
}

string Init()
{
    inv[1] = 1;
    for (int i = 2; i <= LIM; ++i) {
        inv[i] = 1ll * (P - P / i) * inv[P % i] % P;
    }
    return "Success";
}

string status = Init();

typedef vector<int> poly;

void simpl(poly &x)
{
    while (!x.empty() && !x.back()) {
        x.pop_back();
    }
    return;
}

poly operator + (poly x, poly y)
{
    int sz = max(x.size(), y.size());
    poly z(sz);
    x.resize(sz), y.resize(sz);
    for (int i = 0; i < (int)z.size(); ++i) {
        ((z[i] = x[i] + y[i]) >= P) && (z[i] -= P);
    }
    return z;
}

poly operator - (poly x, poly y)
{
    int sz = max(x.size(), y.size());
    poly z(sz);
    x.resize(sz), y.resize(sz);
    for (int i = 0; i < (int)z.size(); ++i) {
        ((z[i] = x[i] - y[i]) < 0) && (z[i] += P);
    }
    return z;
}

poly diff(poly x)
{
    if (x.empty()) {
        return x;
    }
    int sz = x.size() - 1;
    poly y(sz);
    for (int i = 0; i < sz; ++i) {
        y[i] = 1ll * x[i + 1] * (i + 1) % P;
    }
    return y;
}

poly inte(poly x)
{
    if (x.empty()) {
        return x;
    }
    int sz = x.size() + 1;
    poly y(sz);
    for (int i = 1; i < sz; ++i) {
        y[i] = 1ll * x[i - 1] * ksm(i) % P;
    }
    return y;
}

poly NTT(poly f, int type = 0)
{
    int n = f.size();
    assert(n && !(n & (n - 1)));
    poly tr(n);
    for (int i = 1; i < n; ++i) {
        tr[i] = (tr[i >> 1] >> 1) | ((i & 1) ? n >> 1 : 0);
        if (i < tr[i]) {
            swap(f[i], f[tr[i]]);
        }
    }
    for (int len = 2; len <= n; len <<= 1) {
        int p = len >> 1, buf = ksm((type ? iG : G), (P - 1) / len);
        for (int i = 0; i < n; i += len) {
            int now = 1;
            for (int j = i; j < i + p; ++j) {
                int tmp = 1ll * now * f[j + p] % P;
                ((f[j + p] = f[j] - tmp) < 0) && (f[j + p] += P);
                ((f[j] += tmp) >= P) && (f[j] -= P);
                now = 1ll * now * buf % P;
            }
        }
    }
    if (type) {
        int invN = ksm(n);
        for (auto &v : f) {
            v = 1ll * v * invN % P;
        }
    }
    return f;
}

poly operator * (poly x, poly y)
{
    if (x.empty() || y.empty()) {
        return {};
    }
    simpl(x), simpl(y);
    int len = x.size() + y.size() - 1, tLen = 1;
    while (tLen < len) {
        tLen <<= 1;
    }
    x.resize(tLen), y.resize(tLen);
    x = NTT(x), y = NTT(y);
    for (int i = 0; i < tLen; ++i) {
        x[i] = 1ll * x[i] * y[i] % P;
    }
    x = NTT(x, 1);
    simpl(x);
    return x;
}

int f[N][N], C[N][N];

signed main() {
    int n, m, d; scanf("%d%d%d", &n, &m, &d);
    for (int i = C[0][0] = 1; i <= m; ++i) {
        for (int j = C[i][0] = 1; j <= i; ++j) {
            C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % P;
        }
    }
    f[0][1] = 1;
    for (int i = 1; i <= d; ++i) {
        vector<int> f1(n + 1), f2(n + 1), tf1 = {1}, tf2 = {1};
        for (int k = 0; k < i; ++k) {
            for (int l = 1; l <= n; ++l) {
                f1[l] = (f1[l] + f[k][l]) % P;
                if (k != i - 1) f2[l] = (f2[l] + f[k][l]) % P;
            }
        }
        for (int j = 1; j <= m; ++j) {
            tf1 = tf1 * f1, tf1.resize(n + 1);
            tf2 = tf2 * f2, tf2.resize(n + 1);
            for (int k = 0; k <= n; ++k) {
                f[i][k + 1] = (f[i][k + 1] + 1ll * (tf1[k] - tf2[k] + P) * C[m][j]) % P;
            }
        }
    }
    int res = 0;
    for (int i = 0; i <= d; ++i) {
        res = (res + f[i][n]) % P;
    }
    printf("%d\n", res);
    return 0;
}