#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;

namespace {

constexpr int maxn = 1 << 22;
constexpr int mod = 998244353;
constexpr int G = 3;

constexpr int add(int a, int b) {
	return a + b >= mod ? a + b - mod : a + b;
}
constexpr int sub(int a, int b) {
	return a - b < 0 ? a - b + mod : a - b;
}
constexpr int mul(int64_t a, int64_t b) {
	return static_cast<int>(a * b % mod);
}
constexpr int mpow(int a, int64_t k) {
	int r = 1; 
	while (k) {
		if (k & 1) r = mul(r, a);
		k >>= 1;
		a = mul(a, a);
	}
	return r;
}
int minv_small_tbl[maxn];
int minv_small(int a) {
	return minv_small_tbl[a];
}
constexpr int minv(int a) {
	return mpow(a, mod - 2);
}
int fac[maxn], ifac[maxn];
int comb(int a, int b) {
	return mul(fac[a], mul(ifac[b], ifac[a - b]));
}

void init() {
	fac[0] = 1;
	for (int i = 1; i < maxn; ++i)
		fac[i] = mul(fac[i - 1], i);
	ifac[maxn - 1] = minv(fac[maxn - 1]);
	for (int i = maxn - 2; i >= 0; --i)
		ifac[i] = mul(ifac[i + 1], i + 1);
	for (int i = 1; i < maxn; ++i)
		minv_small_tbl[i] = mul(ifac[i], fac[i - 1]);
}

template <int n>
using P = array<int, 1 << n>;

template <int n>
concept pw2 = ((n != 0) and ((n & (-n)) == n));

struct NTT {
	int roots[maxn];
	NTT() {
		int r = mpow(G, (mod - 1) / maxn);
		for (int i = maxn >> 1; i; i >>= 1) {
			roots[i] = 1;
			for (int j = 1; j < i; j++)
				roots[i + j] = mul(roots[i + j - 1], r);
			r = mul(r, r);
		}
	}
	template <int n>
	requires pw2<n>
	void trans(int F[], bool inv = false) {
		for (int i = 0, j = 0; i < n; ++i) {
			if (i < j) swap(F[i], F[j]);
			for (int k = n >> 1; (j ^= k) < k; k >>= 1);
		}
		for (int s = 1; s < n; s *= 2) {
			for (int i = 0; i < n; i += s * 2) {
				for (int j = 0; j < s; ++j) {
					int a = F[i + j];
					int b = mul(F[i + j + s], roots[s + j]);
					F[i + j] = add(a, b);
					F[i + j + s] = sub(a, b);
				}
			}
		}
		if (inv) {
			int invn = minv_small(n);
			for (int i = 0; i < n; ++i)
				F[i] = mul(F[i], invn);
			reverse(F + 1, F + n);
		}
	}
};

NTT ntt;

template <int n>
requires pw2<n>
void Mul(int a[], int b[]) {
	fill_n(a + n, n, 0), fill_n(b + n, n, 0);
	ntt.trans<n * 2>(a), ntt.trans<n * 2>(b);
	for (int i = 0; i < n * 2; ++i)
		a[i] = mul(a[i], b[i]);
	ntt.trans<n * 2>(a, true);
}

template <int n>
requires pw2<n>
void Inv(const int a[], int b[]) {
	if constexpr (n == 1) {
		b[0] = minv(a[0]);
	} else {
		static int c[n * 2];
		Inv<n / 2>(a, b), fill_n(b + n / 2, n / 2 * 3, 0);
		copy_n(a, n, c), fill_n(c + n, n, 0);
		ntt.trans<n * 2>(b), ntt.trans<n * 2>(c);
		for (int i = 0; i < n * 2; ++i)
			b[i] = mul(b[i], sub(2, mul(b[i], c[i])));
		ntt.trans<n * 2>(b, true);
	}
}

template <int n>
requires pw2<n>
void Ln(const int a[], int b[]) {
	static int c[n * 2];
	Inv<n>(a, c);
	for (int i = 0; i + 1 < n; ++i)
		b[i] = mul(i + 1, a[i + 1]);
	b[n - 1] = 0;
	Mul<n>(b, c);
	for (int i = n - 2; i >= 0; --i)
		b[i + 1] = mul(minv_small(i + 1), b[i]);
	b[0] = 0;
}

template <int n>
requires pw2<n>
void Exp(const int a[], int b[]) {
	if constexpr (n == 1) {
		b[0] = 1;
	} else {
		static int c[n * 2];
		Exp<n / 2>(a, b), fill_n(b + n / 2, n / 2, 0);
		Ln<n>(b, c);
		c[0] = mod - 1;
		for (int i = 0; i < n; ++i)
			c[i] = sub(a[i], c[i]);
		Mul<n>(b, c);
	}
}

int a[maxn], b[maxn];

} // namespace

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

	init();
	
	int n, m, k;
	cin >> n >> m >> k;
	for (int i = 0; i <= m; ++i) {
		if (i == k) continue;
		a[i] = mul(comb(2 * i, i), minv_small(i + 1));
	}
	constexpr int m2 = 1 << 20;
	Ln<m2>(a, b);
	for (int i = 0; i < m2; ++i)
		b[i] = mul(b[i], n);
	Exp<m2>(b, a);
	cout << a[m] << '\n';
	return 0;
}