#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
const int N = 2e6 + 10;
const int mod = 998244353;
//#define int long long


int powmod(int a, int b) {
    int res = 1;
    while (b) {
        if (b & 1) res = 1ll * res * a % mod;
        b >>= 1;
        a = 1ll * a * a % mod;
    }
    return res;
}


struct Combinatorial_mathematics {
    vector<int> fac, inv;

    inline int add(int &x, int y) { return x + y >= mod ? x + y - mod : x + y; }

    inline int sub(int &x, int y) { return x - y < 0 ? x - y + mod : x - y; }

    inline int mul(int &x, int y) { return 1ull * x * y % mod; }

    inline int powmod(int a, int b) {
        int res = 1;
        while (b) {
            if (b & 1) res = mul(res, a);
            b >>= 1;
            a = mul(a, a);
        }
        return res;
    }

    inline int Inv(int x) { return powmod(x, mod - 2); }

    Combinatorial_mathematics(int m = 0) : fac(m + 1), inv(m + 1) {
        fac[0] = 1;
        for (int i = 1; i <= m; i++) fac[i] = mul(fac[i - 1], i);
        inv[m] = Inv(fac[m]);
        for (int i = m; i >= 1; i--) inv[i - 1] = mul(inv[i], i);
    }

    inline int C(int n, int m) {
        if (n < m || n < 0 || m < 0) return 0;
        return mul(fac[n], mul(inv[m], inv[n - m]));
    }
};


#define maxn 4000005
#define mod 998244353
#define LL long long

void Inc(int &x, int y) {
    x += y;
    (x >= mod) && (x -= mod);
}

int sub(int x, int y) {
    x -= y;
    (x < 0) && (x += mod);
    return x;
}

inline int Pow(int b, int k, int r = 1) {
    for (; k; k >>= 1, b = 1ll * b * b % mod) if (k & 1) r = 1ll * r * b % mod;
    return r;
}

namespace Math {
    LL w;
    struct N {
        LL a, b;
    };

    N operator*(const N &x, const N &y) { return (N) {(x.a * y.a + w * x.b % mod * y.b) % mod, (x.a * y.b + y.a * x.b) % mod}; }

    inline LL power(N n, LL x) {
        N res = (N) {1, 0};
        for (; x; n = n * n, x >>= 1) if (x & 1) res = res * n;
        return res.a;
    }

    inline bool check(LL x) { return power((N) {x, 0}, (mod - 1) >> 1) == 1; }

    inline int work(LL n) {
        mt19937 rnd(time(0));
        if (n == 0) return 0;
        LL a = rnd() % mod;
        while (!a || check((a * a + mod - n) % mod)) a = rnd() % mod;
        w = (a * a + mod - n) % mod;
        int ans = power((N) {a, 1}, (mod + 1) >> 1);
        return min(ans, mod - ans);
    }
}
#define inv2 499122177
#define I 86583718
int Wl, Wl2, w[maxn], lg[maxn], inv[maxn];

inline void init(int n) {
    for (Wl = 1; n >= Wl << 1; Wl <<= 1);
    int pw = Pow(3, (mod - 1) / (Wl2 = Wl << 1));
    w[Wl] = inv[0] = inv[1] = 1;
    for (int i = Wl + 1; i <= Wl2; i++) w[i] = w[i - 1] * 1ll * pw % mod;
    for (int i = Wl - 1; i >= 1; i--) w[i] = w[i << 1];
    for (int i = 2; i <= Wl2; i++) inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod, lg[i] = lg[i >> 1] + 1;
}

inline int upd(int x) { return x += x >> 31 & mod; }

inline void NTT(int *A, int n, int tp) {
    static int r[maxn] = {};
    static unsigned LL ar[maxn] = {};
    if (tp ^ 1) reverse(A + 1, A + n);
    for (int i = 0; i < n; i++) r[i] = (r[i >> 1] >> 1 | (i & 1) << lg[n] - 1), ar[i] = upd(A[r[i]]);
    for (int L = 1; L < n; L <<= 1)
        for (int s = 0, L2 = L << 1; s < n; s += L2)
            for (int k = s, x = L, t; x < L2; x++, k++) t = ar[k + L] * w[x] % mod, ar[k + L] = ar[k] - t + mod, ar[k] += t;
    for (int i = 0; i < n; i++) A[i] = ar[i] % mod;
    if (tp ^ 1) for (int i = 0; i < n; i++) A[i] = 1ll * A[i] * inv[n] % mod;
}

#define Poly vector<int>

inline Poly Sub(Poly A, Poly B) {
    if (A.size() < B.size()) A.resize(B.size()); else if (A.size() > B.size()) B.resize(A.size());
    Poly C;
    C.resize(A.size());
    for (int i = 0; i < (int) A.size(); i++) C[i] = sub(A[i], B[i]);
    return C;
}

inline Poly Der(Poly A) {
    int n = A.size();
    for (int i = 1; i < n; i++) A[i - 1] = 1ll * i * A[i] % mod;
    A[n - 1] = 0;
    return A;
}

inline Poly Int(Poly A) {
    int n = A.size();
    for (int i = n - 1; i > 0; i--) A[i] = 1ll * A[i - 1] * inv[i] % mod;
    A[0] = 0;
    return A;
}

namespace SemiConvol {
    Poly p[5][16], A;

    void ln(Poly &res, int l, int r, int n, int dep = 0) {
        if (r - l <= 256) {
            r = min(r, n);
            for (int i = l; i < r; ++i) {
                if (i == 0) res[i] = 0; else res[i] = sub(A[i], 1ll * inv[i] * res[i] % mod);
                for (int j = i + 1; j < r; ++j) res[j] = (res[j] + 1ll * res[i] * A[j - i] % mod * i) % mod;
            }
            return;
        }
        int sz = r - l >> 4;
        vector<LL> w[16];
        Poly T(sz * 2);
        int lim = 0;
        for (; lim < 16; lim++) {
            if (l + lim * sz >= n) break;
            w[lim].resize(sz << 1);
        }
        for (int i = 0; i < lim; i++) {
            if (i) {
                for (int j = 0; j < sz * 2; j++) T[j] = w[i][j] % mod;
                NTT(T.data(), sz * 2, -1);
                for (int j = 0; j < sz; j++) Inc(res[l + i * sz + j], T[sz + j]);
            }
            ln(res, l + i * sz, l + (i + 1) * sz, n, dep + 1);
            if (i < lim - 1) {
                for (int j = 0; j < sz; j++) T[j + sz] = 0, T[j] = 1ll * res[l + i * sz + j] * (l + i * sz + j) % mod;
                NTT(T.data(), sz << 1, 1);
                for (int j = i + 1; j < lim; j++) for (int k = 0; k < sz * 2; ++k) w[j][k] += 1ll * T[k] * p[dep][j - i - 1][k];
            }
        }
    }

    void exp(Poly &res, int l, int r, int n, int dep = 0) {
        if (r - l <= 256) {
            r = min(r, n);
            for (int i = l; i < r; ++i) {
                if (i == 0) res[i] = 1; else res[i] = 1ll * res[i] * inv[i] % mod;
                for (int j = i + 1; j < r; ++j) res[j] = (res[j] + 1ll * res[i] * A[j - i] % mod * (j - i)) % mod;
            }
            return;
        }
        int sz = r - l >> 4;
        vector<LL> w[16];
        Poly T(sz * 2);
        int lim = 0;
        for (; lim < 16; lim++) {
            if (l + lim * sz >= n) break;
            w[lim].resize(sz << 1);
        }
        for (int i = 0; i < lim; i++) {
            if (i) {
                for (int j = 0; j < sz * 2; j++) T[j] = w[i][j] % mod;
                NTT(T.data(), sz * 2, -1);
                for (int j = 0; j < sz; j++) Inc(res[l + i * sz + j], T[sz + j]);
            }
            exp(res, l + i * sz, l + (i + 1) * sz, n, dep + 1);
            if (i < lim - 1) {
                for (int j = 0; j < sz; j++) T[j + sz] = 0, T[j] = res[l + i * sz + j];
                NTT(T.data(), sz * 2, 1);
                for (int j = i + 1; j < lim; j++) for (int k = 0; k < sz * 2; ++k) w[j][k] += 1ll * T[k] * p[dep][j - i - 1][k];
            }
        }
    }
}

Poly Exp(Poly A) {
    int n = A.size(), l = 1 << lg[n] + 1;
    A.resize(l << 1);
    Poly res(l);
    SemiConvol::A = A;
    for (int le = l, dep = 0; le > 256; le >>= 4, dep++) {
        int sz = le >> 4;
        for (int i = 0; i < 16; i++) {
            SemiConvol::p[dep][i].resize(sz * 2);
            for (int j = 0; j < (sz << 1); j++) SemiConvol::p[dep][i][j] = 1ll * A[i * sz + j] * (i * sz + j) % mod;
            NTT(SemiConvol::p[dep][i].data(), sz * 2, 1);
        }
    }
    SemiConvol::exp(res, 0, l, n);
    res.resize(n);
    return res;
}

Poly Ln(Poly A) {
    int n = A.size(), l = 1 << lg[n] + 1;
    A.resize(l << 1);
    Poly res(l);
    SemiConvol::A = A;
    for (int le = l, dep = 0; le > 256; le >>= 4, dep++) {
        int sz = le >> 4;
        for (int i = 0; i < 16; i++) {
            SemiConvol::p[dep][i].resize(sz * 2);
            for (int j = 0; j < (sz << 1); j++) SemiConvol::p[dep][i][j] = 1ll * A[i * sz + j] % mod;
            NTT(SemiConvol::p[dep][i].data(), sz * 2, 1);
        }
    }
    SemiConvol::ln(res, 0, l, n);
    res.resize(n);
    return res;
}

inline Poly Sqrt_Rec(Poly A) {
    static int t[maxn];
    int n = A.size();
    A.resize(n << 1);
    Poly C{Pow(Math::work(A[0]), mod - 2)};
    for (int k = 2; k < (n << 1); k <<= 1) {
        Poly B = C;
        B.resize(k << 1);
        memcpy(t, A.data(), k << 2);
        NTT(B.data(), k << 1, 1);
        NTT(t, k << 1, 1);
        for (int i = 0; i < (k << 1); i++) t[i] = 1ll * B[i] * t[i] % mod * B[i] % mod * B[i] % mod;
        NTT(t, k << 1, -1);
        C.resize(k);
        for (int i = (k >> 1); i < k; i++) C[i] = t[i] ? mod - 1ll * inv2 * t[i] % mod : 0;
    }
    C.resize(n);
    return C;
}

inline Poly Pow(Poly A, int k) {
    int n = A.size();
    A = Ln(A);
    for (int i = 1; i < n; i++) A[i] = 1ll * A[i] * k % mod;
    return Exp(A);
}

inline int Init(int n) {
    int m;
    for (m = 1; m <= n; m <<= 1);
    init(m);
    return m;
}

int n, k, m;
Poly a;
int nn, mm, kk;
int AAA[N];

void solve() {
    Combinatorial_mathematics Ci(2000001);
    cin >> nn >> mm >> kk;
    a.resize(mm + 1);
    init(mm + 1);
    for (int i = 0; i <= mm; i++) a[i] = 1ll * Ci.C(2 * i, i) * Ci.Inv(i + 1) % mod;
    a[kk] = 0;
    // vec = a[0-m]
    // res = vec^n;
    // cout << res[m];
    a = Pow(a, nn);
    cout << a[mm] << "\n";
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int _ = 1;
//    cin >> _;
    for (int o = 1; o <= _; o++) {
        //      cout << "Case #<<" << o << ": ";
        solve();
    }
    return 0;
}

/*





*/