To AmShZ, all arrays are equal, but some arrays are more-equal than others. Specifically, the arrays consisting of n elements from 1 to n that can be turned into permutations of numbers from 1 to n by adding a non-negative integer to each element.

Mashtali who wants to appear in every problem statement thinks that an array b consisting of k elements is compatible with a more-equal array a consisting of n elements if for each 1 ≤ i ≤ k we have 1 ≤ b_i ≤ n and also a_{b_1} = a_{b_2} = … = a_{b_k}.

Find the number of pairs of arrays a and b such that a is a more-equal array consisting of n elements and b is an array compatible with a consisting of k elements modulo 998244353.

Note that the elements of b are not necessarily distinct, same holds for a.

Input

The first line of input contains two integers n and k (1 ≤ n ≤ 10^9 , 1 ≤ k ≤ 10^5).

Output

Print a single integer — the answer to the problem modulo 998244353.

Examples

Input


1 1


Output


1


Input


2 2


Output


8


Input


5 4


Output


50400


Input


20 100


Output


807645526


Input


10000000 10000


Output


883232350

Note

There are eight possible pairs for the second example: 

  1. a = \{1, 1\}, b = \{1, 1\} 
  2. a = \{1, 1\}, b = \{1, 2\} 
  3. a = \{1, 1\}, b = \{2, 1\} 
  4. a = \{1, 1\}, b = \{2, 2\} 
  5. a = \{1, 2\}, b = \{1, 1\} 
  6. a = \{1, 2\}, b = \{2, 2\} 
  7. a = \{2, 1\}, b = \{1, 1\} 
  8. a = \{2, 1\}, b = \{2, 2\} 
// coded by whx1003

#include<cmath>
#include<cstdio>
#include<vector>
#include<algorithm>

typedef long long ll;
typedef std::vector<ll> vec;
const ll mod = 998244353, gen = 3;
const ll inv2 = (mod + 1) / 2;
const int maxn = 1E+5 + 5;

namespace IObuf {
	const int LEN = 1 << 20;

	char ibuf[LEN + 5], *p1 = ibuf, *p2 = ibuf;
	char obuf[LEN + 5], *p3 = obuf;

	inline char get() {
#ifdef ONLINE_JUDGE
		return p1 == p2 && (p2 = (p1 = ibuf) + fread(ibuf, 1, LEN, stdin), p1 == p2) ? EOF : *p1++;
#endif
		return getchar();
	}

	inline ll getll(char c = get(), ll x = 0, ll op = 1) {
		while(c < '0' || c > '9') c == '-' && (op = -op), c = get();
		while(c >= '0' && c <= '9') x = x * 10 + c - 48, c = get();
		return x * op;
	}

	inline char* flush() { fwrite(obuf, 1, p3 - obuf, stdout); return p3 = obuf; }
	inline void put(char c) {
#ifdef ONLINE_JUDGE
		p3 == obuf + LEN && flush(); *p3++ = c; return;
#endif
		putchar(c);
	}

	char s[20]; int t = 0;
	inline void putll(ll x, char suf = ' ') {
		if(!x) put('0');
		else {
			while(x) s[++t] = x % 10 + 48, x /= 10;
			while(t) put(s[t--]);
		} put(suf);
	}
}
using IObuf::getll;
using IObuf::putll;

inline ll fsp(ll a, ll b, ll res = 1) {
	for(a %= mod; b; a = a * a % mod, b >>= 1)
		b & 1 ? res = res * a % mod : 0; return res;
}

namespace Math {
	int L = -1; ll _Fac[maxn << 2], _Inv[maxn << 2], _inv[maxn << 2];

	inline void pre(int l) {
		if(L == -1) {
			_Fac[0] = _Fac[1] = 1;
			_Inv[0] = _Inv[1] = 1;
			_inv[1] = 1, L = 1;
			if(l <= L) return;
		}

		for(int i = L + 1; i <= l; ++i) {
			_inv[i] = _inv[mod % i] * (mod - mod / i) % mod;
			_Fac[i] = _Fac[i - 1] * i % mod;
			_Inv[i] = _Inv[i - 1] * _inv[i] % mod;
		}

		L = l;
	}

	inline ll Fac(ll n) { if(L < n) pre(n); return _Fac[n]; }
	inline ll Inv(ll n) { if(L < n) pre(n); return _Inv[n]; }
	inline ll inv(ll n) { if(L < n) pre(n); return _inv[n]; }
	inline ll binom(int n, int k) {
		if(k < 0 || n < k) return 0;
		return Fac(n) * Inv(k) % mod * Inv(n - k) % mod;
	}
}

namespace Poly {
	struct poly {
		vec f;

		// init

		inline poly(ll v = 0) : f(1) { f[0] = v; }
		inline poly(const vec &_f) : f(_f) {}

#if __cplusplus >= 201103L
		inline poly(std::initializer_list<ll> init) : f(init) {}
#endif

		// tools

		inline ll operator[](int p) const { return f[p]; }
		inline ll &operator[](int p) { return f[p]; }

		inline int deg() const { return f.size() - 1; }
		inline void redeg(int d) { f.resize(d + 1); }

		inline poly slice(int d) const {
			if(d < f.size())
				return vec(f.begin(), f.begin() + d + 1);

			vec res(f);
			return res.resize(d + 1), res;
		}

		// operators

		inline poly operator*(const poly &P) const;				// redeg to max(deg(), P.deg())
	};

	int Len = -1, rev[maxn << 2];
	unsigned long long rt[maxn << 3];
	inline void NTTpre(int bit) {
		if(Len >= bit) return;
		for(int i = Len + 1; i <= bit; ++i) {
			ll stp = fsp(gen, mod - 1 >> i);

			rt[1 << i] = 1;
			for(int j = (1 << i) + 1; j < (1 << i + 1); ++j)
				rt[j] = rt[j - 1] * stp % mod;
		} Len = bit;
	}

	unsigned long long tmp[maxn << 2];
	inline void NTT(poly &f, int bit, int op) {
		NTTpre(bit); int N = 1 << bit;

		if(f.deg() < N - 1) f.redeg(N - 1);
		for(int i = 0; i < N; ++i) {
			rev[i] = (rev[i >> 1] >> 1 | (i & 1) << bit - 1);
			tmp[i] = f[rev[i]] + (f[rev[i]] >> 31 & mod);			// magic
		}

		for(int len = 1; len < N; len <<= 1) {
			for(int i = 0; i < N; i += len << 1) {
				for(int k = i, x = len << 1; k < i + len; ++k, ++x) {
					ll g = tmp[k], h = tmp[k + len] * rt[x] % mod;
					tmp[k] = g + h, tmp[k + len] = mod + g - h;
				}
			}
		}

		for(int i = 0; i < N; ++i) f[i] = tmp[i] % mod;
		if(op == -1) {
			reverse(f.f.begin() + 1, f.f.begin() + N);

			ll invN = fsp(N, mod - 2);
			for(int i = 0; i < N; ++i)
				f[i] = f[i] * invN % mod;
		}
	}

	inline poly poly::operator*(const poly &P) const {
		if(std::max(deg(), P.deg()) <= 128) {
			poly res; res.redeg(deg() + P.deg());
			for(int i = 0; i <= deg(); ++i)
				for(int j = 0; j <= P.deg(); ++j)
					(res[i + j] += f[i] * P[j]) %= mod;

			res.redeg(std::max(deg(), P.deg()));
			return res;
		}

		poly F(f), G = P;

		int bit = 0, N = 1;
		while(N <= F.deg() + G.deg()) ++bit, N <<= 1;

		NTT(F, bit, 1), NTT(G, bit, 1);
		for(int i = 0; i < N; ++i)
			F[i] = F[i] * G[i] % mod;
		NTT(F, bit, -1);

		return F.slice(std::max(deg(), P.deg()));
	}
}
using Poly::poly;

ll n, down[maxn]; int k;

inline ll sgn(int x) { return x & 1 ? mod - 1 : 1; }

int main() {
	n = getll(), k = getll();

	poly A, C; A.redeg(k), C.redeg(k);
	for(int i = 0; i <= k; ++i)
		A[i] = Math::Inv(i) * sgn(i) % mod, C[i] = fsp(i, k, Math::Inv(i));
	
	C = C * A;
	
	down[0] = 1;
	for(int i = 1; i <= k; ++i)
		down[i] = down[i - 1] * (n - i + 1) % mod;
	
	ll ans = 0, iv = fsp(n, mod - 2);
	for(int i = 0; i <= k; ++i)
		(ans += fsp(n + 1, n - i + mod - 1, C[i] * down[i] % mod)) %= mod;
	putll(ans), IObuf::flush();
}