#include <bits/stdc++.h>
using namespace std;

#define int long long
#define fp(i, a, b) for (int i = (a), i##_ = (b) + 1; i < i##_; ++i)
#define fd(i, a, b) for (int i = (a), i##_ = (b) - 1; i > i##_; --i)
const int N = 1e6 + 100, P = 998244353;
using ll = int64_t;
using Poly = vector<int>;
using MultiPoly = vector<Poly>;

//快读
template <typename T>void read(T& x){
    x = 0;
    int f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') { if (ch == '-')f = -1; ch = getchar(); }
    while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); }
    x *= f;
}
//二次剩余
/*---------------------------------------------------------------------------*/
class Cipolla {
    int P, I2{};
    using pll = pair<ll, ll>;
#define X first
#define Y second
    ll mul(ll a, ll b) const { return a * b % P; }
    pll mul(pll a, pll b) const { return { (a.X * b.X + I2 * a.Y % P * b.Y) % P, (a.X * b.Y + a.Y * b.X) % P }; }
    template<class T> T POW(T a, int b, T x) { for (; b; b >>= 1, a = mul(a, a)) if (b & 1) x = mul(x, a); return x; }
public:
    Cipolla(int p = 0) : P(p) {}
    pair<int, int> sqrt(int n) {
        int a = rand(), x;
        if (!(n %= P)) return { 0, 0 };
        if (POW(n, (P - 1) >> 1, 1ll) == P - 1) return { -1, -1 };
        while (POW(I2 = ((ll)a * a - n + P) % P, (P - 1) >> 1, 1ll) == 1) a = rand();
        x = (int)POW(pll{ a, 1 }, (P + 1) >> 1, { 1, 0 }).X;
        if (2 * x > P) x = P - x;
        return { x, P - x };
    }
#undef X
#undef Y
};
/*---------------------------------------------------------------------------*/
#define MUL(a, b) (ll(a) * (b) % P)
#define ADD(a, b) (((a) += (b)) >= P ? (a) -= P : 0) // (a += b) %= P
#define SUB(a, b) (((a) -= (b)) < 0 ? (a) += P: 0)  // ((a -= b) += P) %= P

//预处理L以内的逆元(0 ~ L-1)
Poly getInv(int L) { Poly inv(L); inv[1] = 1; fp(i, 2, L - 1) inv[i] = MUL((P - P / i), inv[P % i]); return inv; }
auto inv = getInv(N);

//快速幂
int qpow(ll a, int b = P - 2, ll x = 1) { for (; b; b >>= 1, a = a * a % P) if (b & 1) x = x * a % P; return x; }
/*---------------------------------------------------------------------------*/
namespace NTT {
    const int g = 3;
    Poly Omega(int L) {
        int wn = qpow(g, P / L);
        Poly w(L); w[L >> 1] = 1;
        fp(i, L / 2 + 1, L - 1) w[i] = MUL(w[i - 1], wn);
        fd(i, L / 2 - 1, 1) w[i] = w[i << 1];
        return w;
    }
    auto W = Omega(1 << 23); // 注意这边的size，如果大于3e5，改成23；
    void DIF(int* a, int n) {
        for (int k = n >> 1; k; k >>= 1)
            for (int i = 0, y; i < n; i += k << 1)
                for (int j = 0; j < k; ++j)
                    y = a[i + j + k], a[i + j + k] = MUL(a[i + j] - y + P, W[k + j]), ADD(a[i + j], y);
    }
    void IDIT(int* a, int n) {
        for (int k = 1; k < n; k <<= 1)
            for (int i = 0, x, y; i < n; i += k << 1)
                for (int j = 0; j < k; ++j)
                    x = a[i + j], y = MUL(a[i + j + k], W[k + j]),
                            a[i + j + k] = x - y < 0 ? x - y + P : x - y, ADD(a[i + j], y);
        int Inv = P - (P - 1) / n;
        fp(i, 0, n - 1) a[i] = MUL(a[i], Inv);
        reverse(a + 1, a + n);
    }
}

namespace Polynomial {
    // size确定以及NTT乘法
    int norm(int n) { return 1 << ((int)log2(n - 1) + 1); }
    void norm(Poly& a) { if (!a.empty()) a.resize(norm(a.size()), 0); else a = { 0 }; }
    void DFT(Poly& a) { NTT::DIF(a.data(), a.size()); }
    void IDFT(Poly& a) { NTT::IDIT(a.data(), a.size()); }
    Poly& dot(Poly& a, Poly& b) { fp(i, 0, a.size() - 1) a[i] = MUL(a[i], b[i]); return a; }

    // 和整数的乘除运算
    Poly& operator*=(Poly& a, int b) { for (auto& x : a) x = MUL(x, b); return a; }
    Poly operator*(Poly a, int b) { return a *= b; }
    Poly operator*(int a, Poly b) { return b * a; }
    Poly& operator/=(Poly& a, int b) { return a *= qpow(b); }
    Poly operator/(Poly a, int b) { return a /= b; }

    // 多项式之间的加减运算
    Poly& operator+=(Poly& a, Poly b) {
        a.resize(max(a.size(), b.size()));
        fp(i, 0, b.size() - 1) ADD(a[i], b[i]);
        return a;
    }
    Poly operator+(Poly a, Poly b) { return a += b; }
    Poly& operator-=(Poly& a, Poly b) {
        a.resize(max(a.size(), b.size()));
        fp(i, 0, b.size() - 1) SUB(a[i], b[i]);
        return a;
    }
    Poly operator-(Poly a, Poly b) { return a -= b; }

    // 多项式乘法
    Poly operator*(Poly a, Poly b) {
        int n = a.size() + b.size() - 1, L = norm(n);
        if (a.size() <= 30 || b.size() <= 30) {
            Poly c(n);
            fp(i, 0, a.size() - 1) fp(j, 0, b.size() - 1)
                    c[i + j] = (c[i + j] + (ll)a[i] * b[j]) % P;
            return c;
        }
        a.resize(L), b.resize(L);
        DFT(a), DFT(b), dot(a, b), IDFT(a);
        return a.resize(n), a;
    }

    // 多项式逆元
    Poly Inv2k(Poly a) { // |a| = 2 ^ k
        int n = a.size(), m = n >> 1;
        if (n == 1) return { qpow(a[0]) };
        Poly b = Inv2k(Poly(a.begin(), a.begin() + m)), c = b;
        b.resize(n), DFT(a), DFT(b), dot(a, b), IDFT(a);
        fp(i, 0, n - 1) a[i] = i < m ? 0 : P - a[i];
        DFT(a), dot(a, b), IDFT(a);
        return move(c.begin(), c.end(), a.begin()), a;
    }
    Poly Inv(Poly a) {
        int n = a.size();
        norm(a), a = Inv2k(a);
        return a.resize(n), a;
    }

    // 多项式除法/取模
    Poly operator/(Poly a, Poly b) {
        int k = a.size() - b.size() + 1;
        if (k < 0) return { 0 };
        reverse(a.begin(), a.end());
        reverse(b.begin(), b.end());
        b.resize(k), a = a * Inv(b);
        a.resize(k), reverse(a.begin(), a.end());
        return a;
    }
    pair<Poly, Poly> operator%(Poly a, const Poly& b) {
        Poly c = a / b;
        a -= b * c, a.resize(b.size() - 1);
        return { c, a };
    }

    // 多项式求导积分
    Poly deriv(Poly a) {
        fp(i, 1, a.size() - 1) a[i - 1] = MUL(i, a[i]);
        return a.pop_back(), a;
    }
    Poly integ(Poly a) {
        a.push_back(0);
        fd(i, a.size() - 1, 1) a[i] = MUL(inv[i], a[i - 1]);
        return a[0] = 0, a;
    }

    // 取ln
    Poly Ln(Poly a) {
        int n = a.size();
        a = deriv(a) * Inv(a);
        return a.resize(n - 1), integ(a);
    }

    // 取exp
    Poly Exp(Poly a) {
        int n = a.size(), k = norm(n);
        Poly b = { 1 }, c, d; a.resize(k);
        for (int L = 2; L <= k; L <<= 1) {
            d = b, b.resize(L), c = Ln(b), c.resize(L);
            fp(i, 0, L - 1) c[i] = a[i] - c[i] + (a[i] < c[i] ? P : 0);
            ADD(c[0], 1), DFT(b), DFT(c), dot(b, c), IDFT(b);
            move(d.begin(), d.end(), b.begin());
        }
        return b.resize(n), b;
    }

    // 开根
    Poly Sqrt(Poly a) {
        int n = a.size(), k = norm(n); a.resize(k);
        Poly b = { (new Cipolla(P))->sqrt(a[0]).first, 0 }, c;
        for (int L = 2; L <= k; L <<= 1) {
            b.resize(L), c = Poly(a.begin(), a.begin() + L) * Inv2k(b);
            fp(i, L / 2, L - 1) b[i] = MUL(c[i], (P + 1) / 2);
        }
        return b.resize(n), b;
    }

    // 多项式快速幂
    Poly Pow1(Poly& a, int b) { return Exp(Ln(a) * b); } // a[0] = 1, 循环卷积
    Poly Pow2(Poly& a, int b) {
        int n = (a.size() - 1) * b + 1, L = norm(n);
        a.resize(L);
        DFT(a);
        fp(i, 0, L - 1) a[i] = qpow(a[i], b);
        IDFT(a);
        return a;
    }
    Poly Pow(Poly a, int b1, int b2) { // b1 = b % P, b2 = b % phi(P) and b >= n if a[0] > 0
        int n = a.size(), d = 0, k;
        while (d < n && !a[d]) ++d;
        if ((ll)d * b1 >= n) return Poly(n);
        a.erase(a.begin(), a.begin() + d);
        k = qpow(a[0]), norm(a *= k);
        a = Pow1(a, b1) * qpow(k, P - 1 - b2);
        a.resize(n), d *= b1;
        fd(i, n - 1, 0) a[i] = i >= d ? a[i - d] : 0;
        return a;
    }
}
using namespace Polynomial;

int infac[N], fac[N];

void init() {
    infac[0] = fac[0] = 1;
    for (int i = 1; i < N; i ++ ) {
        fac[i] = fac[i - 1] * i % P;
        infac[i] = infac[i - 1] * inv[i] % P;
    }
}

int C(int a, int b) {
    if (a < 0 || b < 0 || a < b) return 0;
    return fac[a] * infac[b] % P * infac[a - b] % P;
}

int A(int a, int b) {
    if (a < b || a < 0 || b < 0) return 0;
    return fac[a] * infac[a - b] % P;
}

signed main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    init();
    int n, m;
    cin >> n >> m;
    Poly g(m + 1);
    int ans = 0;
    for(int i = 0; i <= m; ++i) g[i] = A(m, i) * C(m, i) % P;
    Poly f = Pow2(g, n);
    for (int i = 0; i <= n * m; i ++ ) {
        if (i & 1) ans -= fac[n * m - i] * f[i] % P;
        else ans += fac[n * m - i] * f[i] % P;
        ans = (ans % P + P) % P;
    }
    cout << ans << endl;

    return 0;
}