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

using ll = long long;
using pii = pair<int, int>;

template <int32_t MOD = 1000000007>
struct Mint {
	int32_t value;
	Mint() : value(0) {}
	Mint(int64_t value_) {
		value_ %= MOD;
		if (value_ < 0) value_ += MOD;
		value = value_;
	}
	inline Mint &operator += (const Mint &other) { this->value += other.value; if (this->value >= MOD) this->value -= MOD; return *this; }
	inline Mint &operator -= (const Mint &other) { this->value -= other.value; if (this->value <	   0) this->value += MOD; return *this; }
	inline Mint &operator *= (const Mint &other) { this->value = (int64_t)this->value * other.value % MOD; if (this->value < 0) this->value += MOD; return *this; }
	inline Mint &operator /= (const Mint &other) { return *this = *this * other.inv(); }

	inline Mint operator + () const { return *this; }
	inline Mint operator - () const { return Mint(this->value ? MOD - this->value : 0); }

	inline friend Mint operator + (const Mint& lhs, const Mint& rhs) { return Mint(lhs) += rhs; }
	inline friend Mint operator - (const Mint& lhs, const Mint& rhs) { return Mint(lhs) -= rhs; }
	inline friend Mint operator * (const Mint& lhs, const Mint& rhs) { return Mint(lhs) *= rhs; }
	inline friend Mint operator / (const Mint& lhs, const Mint& rhs) { return Mint(lhs) /= rhs; }
	
	Mint pow(uint64_t k) const {
		Mint x = *this, y = 1;
		for (; k; k >>= 1) { if (k & 1) y *= x; x *= x; }
		return y;
	}

	Mint sqrt() const {
		if (value == 0) return 0;
		if (MOD == 2) return 1;
		if (pow((MOD - 1) >> 1) == MOD - 1)	return 0; // does not exist, it should be -1, but kept as 0 for this program
		unsigned int Q = MOD - 1, M = 0, i;
		Mint zQ; while (!(Q & 1)) Q >>= 1, M++;
		for (int z = 1; ; z++) {
			if (Mint(z).pow((MOD - 1) >> 1) == MOD - 1) {
				zQ = Mint(z).pow(Q); break;
			}
		}
		Mint t = pow(Q), R = pow((Q + 1) >> 1), r;
		while (true) {
			if (t == 1) { r = R; break; }
			for (i = 1; Mint(t).pow(1 << i) != 1; i++);
			Mint b = Mint(zQ).pow(1 << (M - 1 - i));
			M = i, zQ = b * b, t = t * zQ, R = R * b;
		}
		return min(r, - r + MOD);
	}

	Mint inv() const { return pow(MOD - 2); } // MOD must be a prime
	
	friend bool operator==(const Mint& lhs, const Mint& rhs) { return lhs.value == rhs.value; }
	friend bool operator!=(const Mint& lhs, const Mint& rhs) { return lhs.value != rhs.value; }
	friend bool operator<(const Mint& lhs, const Mint& rhs) { return lhs.value < rhs.value; }
	friend bool operator>(const Mint& lhs, const Mint& rhs) { return lhs.value > rhs.value; }

	friend Mint operator * (int32_t value, Mint n) { return Mint(value) * n; }
	friend Mint operator * (int64_t value, Mint n) { return Mint(value) * n; }

	friend ostream &operator << (std::ostream &os, const Mint &n) { return os << n.value; }
};

template <typename T, int64_t MOD = 1000000007>
struct Combin {
	int _n;
	vector<T> _fac;
    vector<T> _invfac;
    vector<T> _inv;
    
    Combin() : _n{0}, _fac{1}, _invfac{1}, _inv{0} {}
    Combin(int n) : Combin() {
        init(n);
    }
    
    void init(int m) {
        if (m <= _n) return;
        _fac.resize(m + 1);
        _invfac.resize(m + 1);
        _inv.resize(m + 1);
        
        for (int i = _n + 1; i <= m; i++) {
			_fac[i] = _fac[i - 1] * i;
			if (i == 1) {
				_inv[i] = _invfac[i] = 1;
			}
			else {
				_inv[i] = _inv[MOD % i] * (MOD - MOD / i);
				_invfac[i] = _invfac[i - 1] * _inv[i];
			}
		}
        _n = m;
    }
    
    T fac(int m) {
        if (m > _n) init(2 * m);
        return _fac[m];
    }
    T invfac(int m) {
        if (m > _n) init(2 * m);
        return _invfac[m];
    }
    T inv(int m) {
        if (m > _n) init(2 * m);
        return _inv[m];
    }
    T binom(int n, int m) {
        if (n < m || m < 0) return 0;
        return fac(n) * invfac(m) * invfac(n - m);
    }
	T catalan(int n) {
		return binom(2 * n, n) * inv(n + 1);
    }
};

using mint = Mint<998244353>;
using combin = Combin<mint, 998244353>;

void solve() {
	ll n, k;
	cin >> n >> k;

	mint ans = 0;
	combin cb;

	mint denom = mint(n).pow(k);

	if (k % 2 == 1) {
		ans = mint(n + 1) / 2;
	}
	else {
		mint Ed = 0;
		for (int i = 1; i <= n - 1; i++) {
			mint pi = mint(i).pow(k / 2) * mint(n - i).pow(k / 2) * cb.binom(k, k / 2) / denom;
			Ed += pi;
		}
		ans = mint(n + 1) / 2 - Ed / 2;
	}

	ans *= denom;

	cout << ans.value << "\n";
}

int main() {
	cin.tie(0)->sync_with_stdio(0);
	// int t;
	// cin >> t;
	// while (t--) {
		solve();
	// }	
}