#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include template struct ModInt { int x; ModInt() : x(0) {} ModInt(long long y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {} ModInt& operator+=(const ModInt& p) { if ((x += p.x) >= mod) x -= mod; return *this; } ModInt& operator-=(const ModInt& p) { if ((x += mod - p.x) >= mod) x -= mod; return *this; } ModInt& operator*=(const ModInt& p) { x = (int)(1LL * x * p.x % mod); return *this; } ModInt& operator/=(const ModInt& p) { *this *= p.inverse(); return *this; } ModInt& operator^=(long long p) { // quick_pow here:3 ModInt res = 1; for (; p; p >>= 1) { if (p & 1) res *= *this; *this *= *this; } return *this = res; } ModInt operator-() const { return ModInt(-x); } ModInt operator+(const ModInt& p) const { return ModInt(*this) += p; } ModInt operator-(const ModInt& p) const { return ModInt(*this) -= p; } ModInt operator*(const ModInt& p) const { return ModInt(*this) *= p; } ModInt operator/(const ModInt& p) const { return ModInt(*this) /= p; } ModInt operator^(long long p) const { return ModInt(*this) ^= p; } bool operator==(const ModInt& p) const { return x == p.x; } bool operator!=(const ModInt& p) const { return x != p.x; } explicit operator int() const { return x; } // added by QCFium ModInt operator=(const int p) { x = p; return ModInt(*this); } // added by QCFium ModInt inverse() const { int a = x, b = mod, u = 1, v = 0, t; while (b > 0) { t = a / b; a -= t * b; std::swap(a, b); u -= t * v; std::swap(u, v); } return ModInt(u); } friend std::ostream& operator<<(std::ostream& os, const ModInt& p) { return os << p.x; } friend std::istream& operator>>(std::istream& is, ModInt& a) { long long x; is >> x; a = ModInt(x); return (is); } }; using mint = ModInt<998244353>; // const int MOD = 1000000007; const int MOD = 998244353; struct MComb { std::vector fact; std::vector inversed; MComb(int n) { // O(n+log(mod)) fact = std::vector(n + 1, 1); for (int i = 1; i <= n; i++) fact[i] = fact[i - 1] * mint(i); inversed = std::vector(n + 1); inversed[n] = fact[n] ^ (MOD - 2); for (int i = n - 1; i >= 0; i--) inversed[i] = inversed[i + 1] * mint(i + 1); } mint ncr(int n, int r) { if (n < r) return 0; return (fact[n] * inversed[r] * inversed[n - r]); } mint npr(int n, int r) { return (fact[n] * inversed[n - r]); } mint nhr(int n, int r) { assert(n + r - 1 < (int)fact.size()); return ncr(n + r - 1, r); } }; mint ncr(int n, int r) { mint res = 1; for (int i = n - r + 1; i <= n; i++) res *= i; for (int i = 1; i <= r; i++) res /= i; return res; } template std::vector get_divisors(T x, bool sorted = true) { std::vector res; for (T i = 1; i <= x / i; i++) if (x % i == 0) { res.push_back(i); if (i != x / i) res.push_back(x / i); } if (sorted) std::sort(res.begin(), res.end()); return res; } template struct FenwickTree { std::vector bit; int n; FenwickTree(int _n) : n(_n), bit(_n) {} T sum(int r) { int ret = 0; for (; r >= 0; r = (r & (r + 1)) - 1) ret += bit[r]; return ret; } T sum(int l, int r) { assert(l <= r); return sum(r) - sum(l - 1); } // [l, r] void add(int idx, int delta) { for (; idx < n; idx = idx | (idx + 1)) bit[idx] += delta; } }; template struct DSU { std::vector f, siz; DSU(int n) : f(n), siz(n, 1) { std::iota(f.begin(), f.end(), 0); } T leader(T x) { while (x != f[x]) x = f[x] = f[f[x]]; return x; } bool same(T x, T y) { return leader(x) == leader(y); } bool merge(T x, T y) { x = leader(x); y = leader(y); if (x == y) return false; siz[x] += siz[y]; f[y] = x; return true; } T size(int x) { return siz[leader(x)]; } }; void solve() { int n, m; std::cin >> n >> m; std::vector dp(m, std::vector(3, (mint)0)); dp[0][0] = 1; dp[0][1] = n; dp[0][2] = (n < 4) ? 0 : (mint)n * (n - 1) / 2 - n; for (int i = 0; i < m - 1; i++) { dp[i + 1][0] = dp[i][0] + dp[i][1] + dp[i][2]; dp[i + 1][1] = dp[i][0] * n + dp[i][1] * (n - 1) + dp[i][2] * (n - 2); if (n < 4) dp[i + 1][2] = 0; else { dp[i + 1][2] += dp[i][0] * (n * (n - 1) / 2 - n); dp[i + 1][2] += dp[i][1] * ((n - 1) * (n - 2) / 2 - (n - 2)); dp[i + 1][2] += dp[i][2] * ((n - 2) * (n - 3) / 2 - (n - 4)); } } std::cout << dp[m - 1][0] + dp[m - 1][1] + dp[m - 1][2] << '\n'; } int main() { std::ios_base::sync_with_stdio(false); std::cin.tie(nullptr); int t = 1; std::cin >> t; while (t--) solve(); }