#include <bits/stdc++.h>

using namespace std;

#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()

typedef long long ll;
typedef pair<int, int> pii;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

template<typename T>
std::ostream& operator << (std::ostream& os, const vector<T>& a) {
    for (const T& x : a) {
        os << x << ' ';
    }
    return os;
}

template <int m>
struct mint {
    int x = 0;
    mint(int64_t a = 0) { if (a < 0) a = a % m + m; if (a >= m) a %= m; x = a; }
    friend istream& operator>>(istream& in, mint& a) { int64_t y; in >> y; a = y; return in; }
    friend ostream& operator<<(ostream& out, mint a) { return out << a.x; }
    explicit operator int() const { return x; }
    static int mod_inv(int a, int mod = m) {
        int g = mod, r = a, z = 0, y = 1;
        while (r != 0) { int q = g / r; g %= r; swap(g, r); z -= q * y; swap(z, y); }
        return z < 0 ? z + mod : z;
    }
    mint inv() const { return mod_inv(x, m); }
    friend mint binpow(mint a, int64_t b) { mint res = 1; while (b) { if (b & 1) res *= a; b >>= 1; a *= a; } return res; }
    mint pow(int64_t b) const { return binpow(*this, b); }
    mint operator-() const { return x ? m - x : 0; }
    mint& operator+=(const mint& a) { x += a.x; if (x >= m) x -= m; return *this; }
    mint& operator-=(const mint& a) { x -= a.x; if (x < 0) x += m; return *this; }
    static unsigned fast_mod(uint64_t x, unsigned mod = m) {
#if defined(_WIN32) && !defined(_WIN64)
        // Optimized mod for Codeforces 32-bit machines.
        // x must be less than 2^32 * mod for this to work, so that x / mod fits in a 32-bit integer.
        unsigned x_high = x >> 32, x_low = (unsigned) x; unsigned quot, rem;
        asm("divl %4\n" : "=a" (quot), "=d" (rem) : "d" (x_high), "a" (x_low), "r" (mod));
        return rem;
#else
        return x % mod;
#endif
    }
    mint& operator*=(const mint& a) { x = fast_mod((uint64_t) x * a.x); return *this; }
    mint& operator/=(const mint& a) { return *this *= a.inv(); }
    friend mint operator+(mint a, const mint& b) { return a += b; }
    friend mint operator-(mint a, const mint& b) { return a -= b; }
    friend mint operator*(mint a, const mint& b) { return a *= b; }
    friend mint operator/(mint a, const mint& b) { return a /= b; }
    mint& operator++() { x = x == m - 1 ? 0 : x + 1; return *this; }
    mint& operator--() { x = x == 0 ? m - 1 : x - 1; return *this; }
    mint operator++(int) { mint a = *this; ++*this; return a; }
    mint operator--(int) { mint a = *this; --*this; return a; }
    bool operator==(const mint& a) const { return x == a.x; }
    bool operator!=(const mint& a) const { return x != a.x; }
};

const int mod = 998244353; // 985661441
const int K = 1 << 21; // be careful
const mint<mod> root = binpow(mint<mod>(3), (mod - 1) / K); 
// 3 is a primitive root modulo mod

typedef vector<mint<mod>> poly;

mint<mod> prec_w[K / 2];
mint<mod> w[K];

bool initialized = 0;
void init() {
    if (initialized) {
        return;
    }
    initialized = 1;
    prec_w[0] = 1;
    for (int i = 1; i < K / 2; i++) {
        prec_w[i] = prec_w[i - 1] * root;
    }
    for (int i = 1; i < K; i *= 2) {
        for (int j = 0; j < i; j++) {
            w[i + j] = prec_w[K / (2 * i) * j];
        }
    }
}

void fft(mint<mod>* in, mint<mod>* out, int n, int k = 1) {
    //cout << n << endl;
    if (n == 1) {
        *out = *in;
        return;
    }
    n /= 2;
    fft(in, out, n, 2 * k);
    fft(in + k, out + n, n, 2 * k);
    for (int i = 0; i < n; i++) {
        mint<mod> t = out[i + n] * w[i + n];
        out[i + n] = out[i] - t;
        out[i] += t;
    }
}

poly eval(poly& a) {
    while (__builtin_popcount(a.size()) != 1) {
        a.push_back(0);
    }
    poly res(a.size());
    fft(a.data(), res.data(), a.size());
    return res;
}

poly inter(poly a) {
    int n = a.size();
    poly res(n);
    fft(a.data(), res.data(), n);
    for (int i = 0; i < n; i++) {
        res[i] /= n;
    }
    reverse(res.begin() + 1, res.end());
    return res;
}

using Mint = mint<mod>;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n, m;
    cin >> n >> m;

    int N = n * m;
    vector<Mint> fact(N + 1), rfact(N + 1);
    fact[0] = 1;
    for (int i = 1; i <= N; ++i) {
        fact[i] = i * fact[i - 1];
    }
    rfact[N] = fact[N].inv();
    for (int i = N; i > 0; --i) {
        rfact[i - 1] = rfact[i] * i;
    }

    auto C = [&](int n1, int k1) {
        return fact[n1] * rfact[k1] * rfact[n1 - k1];
    };

    init();

    int L = 1 << 20;
    vector<Mint> a(L, 0);
    vector<Mint> res(L);
    for (int i = 0; i <= m; ++i) {
        if (i & 1) {
            a[i] = mod - C(m, i) * C(m, i) * fact[i];
        } else {
            a[i] = C(m, i) * C(m, i) * fact[i];
        }
    }
    fft(a.data(), res.data(), L);
    for (int i = 0; i < L; ++i) {
        res[i] = res[i].pow(n);
    }
    vector<Mint> b(L, 0);
    fft(res.data(), b.data(), L);
    reverse(b.begin() + 1, b.end());
    for (int i = 0; i < L; ++i) {
        b[i] /= L;
    }
    
    Mint ans = 0;
    for (int k = 0; k <= N; ++k) {
        ans += b[N - k] * fact[k];
    }

    cout << ans << '\n';

    return 0;
}