#include <bits/stdc++.h>

template <class T>
inline void read(T &res)
{
	char ch; bool flag = false; res = 0;
	while (ch = getchar(), !isdigit(ch) && ch != '-');
	ch == '-' ? flag = true : res = ch ^ 48;
	while (ch = getchar(), isdigit(ch))
		res = res * 10 + ch - 48;
	flag ? res = -res : 0;
}

template <class T>
inline void nonnegative_put(T x)
{
	if (x > 9)
		nonnegative_put(x / 10);
	putchar(x % 10 + 48);
}

template <class T>
inline void put(T x)
{
	if (x < 0)
		x = -x, putchar('-');
	nonnegative_put(x);
}

template <class T>
inline void CkMin(T &x, T y) {x > y ? x = y : 0;}
template <class T>
inline void CkMax(T &x, T y) {x < y ? x = y : 0;}
template <class T>
inline T Min(T x, T y) {return x < y ? x : y;}
template <class T>
inline T Max(T x, T y) {return x > y ? x : y;}
template <class T>
inline T Abs(T x) {return x < 0 ? -x : x;}
template <class T>
inline T Sqr(T x) {return x * x;} 
//call Sqr((ll)x) when the type of returned value is "long long".

using std::map;
using std::set;
using std::pair;
using std::bitset;
using std::string;
using std::vector;
using std::complex;
using std::multiset;
using std::priority_queue;

typedef long long ll;
typedef long double ld;
typedef complex<ld> com;
typedef pair<int, int> pir;
const ld pi = acos(-1.0);
const ld eps = 1e-8;
const int Maxn = 1e9;
const int Minn = -1e9;
const int mod = 998244353;
const int inv3 = (mod + 1) / 3; 
const int N = 3e6 + 5;
int n, m, lim, ans;
int rev[N], tw[N], fac[N], ifac[N];

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

inline void dec(int &x, int y)
{
	x -= y;
	x < 0 ? x += mod : 0;
}

inline int quick_pow(int x, int k)
{
	int res = 1;
	while (k)
	{
		if (k & 1)
			res = 1ll * res * x % mod;
		x = 1ll * x * x % mod;
		k >>= 1;
	}
	return res;
}

inline void DFT(vector<int> &a, int opt)
{
	int n = a.size(), g = opt == 1 ? 3 : inv3;
	for (int i = 0; i < n; ++i)
		if (i < rev[i])
			std::swap(a[i], a[rev[i]]);
	for (int k = 1; k < n; k <<= 1)
	{
		int w = quick_pow(g, (mod - 1) / (k << 1));
		tw[0] = 1;
		for (int j = 1; j < k; ++j)
			tw[j] = 1ll * tw[j - 1] * w % mod;
		for (int i = 0; i < n; i += k << 1)
		{
			for (int j = 0; j < k; ++j)
			{
				int u = a[i + j],
					v = 1ll * tw[j] * a[i + j + k] % mod;
				add(a[i + j] = u, v);
				dec(a[i + j + k] = u, v);
			}
		}
	}
	if (opt == -1)
	{
		int inv_n = quick_pow(n, mod - 2); 
		for (int i = 0; i < n; ++i)
			a[i] = 1ll * a[i] * inv_n % mod;
	}
}

int main()
{
	read(n); read(m);
	int lim = n * m;
	fac[0] = 1;
	for (int i = 1; i <= lim; ++i)
		fac[i] = 1ll * i * fac[i - 1] % mod;
	ifac[lim] = quick_pow(fac[lim], mod - 2);
	for (int i = lim; i >= 1; --i)
		ifac[i - 1] = 1ll * i * ifac[i] % mod;
	
	vector<int> f;
	f.resize(m + 1);
	for (int i = 0; i <= m; ++i)
	{
		int tmp = 1ll * fac[m] * fac[m] % mod * ifac[i] % mod * ifac[m - i] % mod * ifac[m - i] % mod;
		if (i & 1)
			dec(f[i], tmp);
		else 
			f[i] = tmp;
	}
	int _m = 0, pn;
	for (pn = 1; pn <= lim; pn <<= 1)
		++_m;
	f.resize(pn);
	for (int i = 1; i < pn; ++i)
		rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (_m - 1));
	DFT(f, 1);
	for (int i = 0; i < pn; ++i)
		f[i] = quick_pow(f[i], n);
	DFT(f, -1);
	f.resize(lim + 1);
	for (int i = 0; i <= lim; ++i)
		 ans = (1ll * f[i] * fac[lim - i] + ans) % mod;
	put(ans), putchar('\n');
}