#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 998244353;

constexpr ll modPow(ll a, ll b, ll c) {
	return (b&1) ? (a * modPow(a, b-1, c) % c)
		: (b ? modPow(a*a % c, b/2, c) : 1);
}

struct FactPrecalc {
	private:
		const int P;
		vector<int> fact, inv_fact;
	public:
		FactPrecalc(int n, int p) : P(p), fact(n+1, 1), inv_fact(n+1, 1) {
			for (int i = 2; i <= n; ++i) fact[i] = (ll)fact[i-1] * i % P;
			inv_fact[n] = modPow(fact[n], P-2, P);
			for (int i = n-1; i >= 0; --i) inv_fact[i] = (ll)inv_fact[i+1] * (i+1) % P;
		}

		ll operator()(ll a, ll b) const {
			if (a < b) return 0;
			ll div = (ll)inv_fact[a-b] * inv_fact[b] % P;
			return div * fact[a] % P;
		}
		ll operator[](int i) const { return fact[i]; }
		ll inv(int i) const { return inv_fact[i]; }
};

// Assume first we cannot put 1 after a 1, or a m after a m.
// DP[s][i][k]: ways to get to a sequence of size s, where last value is {1, m}[i] and there are k gaps [1, m]
//	-> Since there are k gaps, there are also s - (k+1) elements in them. The total size of the gaps is (m-2) * k.
//		-> DP[s+1][i][k] += DP[s][i][k] * ((m-2) * k - (s - (k+1)))
//	-> We may create a new gap, there is a unique way of doing this
//		-> DP[s+1][i ^ 1][k + 1] += DP[s][i][k]

const int N = 3000;
ll dp[N];
ll nxt[N];

int main() {
	int n;
	ll m;
	cin >> n >> m;
	++n;

	FactPrecalc binom(n, MOD);
	
	dp[0] = 1;
	ll res = 0;
	for (int s = 1; s < n; ++s) {
		for (int k = 0; k < s; ++k) {
			ll mult = (m-2) * k - (s - (k+1));
			if (mult > 0) nxt[k] = (nxt[k] + dp[k] * (mult % MOD)) % MOD;
			nxt[k+1] = (nxt[k+1] + dp[k]) % MOD;
		}
		for (int k = 0; k <= s; ++k) {
			res = (res + binom(n-1, n-s) * dp[k]) % MOD;
			dp[k] = nxt[k];
			nxt[k] = 0;
		}
	}
	for (int k = 0; k < n; ++k) res = (res + dp[k]) % MOD;

	cout << res << '\n';
}