#include <iostream>
#include <vector>
#include <limits.h>
#include <algorithm>
#include <string>
#include <math.h>
#include <limits.h>
#include <queue>
#include <map>
#include <set>
#include <iomanip>
#include <bitset>
#include <cassert>
#include <random>
#include <functional>
#include <stack>
#include <iomanip>
#include <cassert>
//#include <boost/multiprecision/cpp_int.hpp>
#include <complex>
#include <cstdio>
#include <list>
#include <bitset>

//< in.txt > out.txt
using namespace std;
//std::ios::sync_with_stdio(false);
//std::cin.tie(0);
const long long MOD = 998244353;
const long long INF = 1e18;
typedef long long LL;
typedef long double LD;
typedef pair<LL, LL> PLL;
typedef pair<LD, LL> pdl;
typedef pair<LD, LD> pdd;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned long long ULL;
//typedef boost::multiprecision::cpp_int bigint;

class Modint {
public:
	LL v;
	Modint(LL _v) {
		_v %= MOD;
		if (_v < 0)_v += MOD;
		v = _v;
	}
	Modint operator+=(Modint m);
	Modint operator-=(Modint m);
	Modint operator*=(Modint m);
	friend ostream& operator<<(ostream& st, Modint m);
	friend ostream& operator>>(ostream& st, Modint m);
	Modint() :v(0) {}
	static Modint one;
};
Modint Modint::one = Modint(1);
ostream& operator<<(ostream& st, Modint m) {
	cout << m.v;
	return st;
}
ostream& operator>>(ostream& st, Modint m) {
	LL v;
	cin >> v;
	m.v = v % MOD;
	return st;
}
Modint operator+(Modint a, Modint b) {
	Modint r;
	r.v = a.v + b.v;
	if (r.v >= MOD)r.v -= MOD;
	return r;
}
Modint operator-(Modint a, Modint b) {
	Modint r;
	r.v = a.v - b.v;
	if (r.v < 0)r.v += MOD;
	return r;
}
Modint operator*(Modint a, Modint b) {
	return Modint((a.v * b.v) % MOD);
}
Modint operator+(Modint a, LL b) {
	return Modint(a.v + b);
}
Modint operator+(LL a, Modint b) {
	return Modint(a + b.v);
}
Modint operator-(Modint a, LL b) {
	return Modint(a.v - b);
}
Modint operator-(LL a, Modint b) {
	return Modint(a - b.v);
}
Modint operator*(Modint a, LL b) {
	return Modint(a.v * (b % MOD));
}
Modint operator*(LL a, Modint b) {
	return Modint((a % MOD) * b.v);
}
Modint Modint::operator+=(Modint m) {
	*this = *this + m;
	return *this;
}
Modint Modint::operator-=(Modint m) {
	*this = *this - m;
	return *this;
}
Modint Modint::operator*=(Modint m) {
	*this = *this * m;
	return *this;
}
template<class T>
T pow(T& base, LL p) {
	if (p == 0)return T();
	else if (p == 1)return base;
	T ret = pow(base, p / 2);
	ret *= ret;
	if (p & 1)ret *= base;
	return ret;
}
template<class T>
T modpow(T base, LL p) {
	if (p == 0)return T();
	else if (p == 1)return base;
	T ret = modpow(base, p / 2);
	ret *= ret;
	if (p & 1)ret *= base;
	return ret;
}

//拡張拡張Euclidの互除法による(階乗)逆元の求め方
//O(N)
void stairs(long long N, vector<long long>& st, long long mod = 1e9 + 7) {
	st.resize(N + 1, 1);
	for (long long n = 2; n <= N; n++) {
		st[n] = (st[n - 1] * n) % mod;
	}
}

LL stair(LL N, LL mod = 1e9 + 7) {
	LL ans = 1;
	for (LL n = 2; n <= N; n++)ans = (ans * n) % mod;
	return ans;
}

void modinvs(long long N, vector<long long>& inv, vector<long long>& sinv, long long mod = 1e9 + 7) {
	inv.resize(N + 1);
	sinv.resize(N + 1);
	inv[1] = 1;
	sinv[0] = 1;
	sinv[1] = 1;
	for (int n = 2; n <= N; n++) {
		inv[n] = mod - (inv[mod % n] * (mod / n)) % mod;
		sinv[n] = (sinv[n - 1] * inv[n]) % mod;
	}
}

//(n^(-1),(n!)^(-1))
PLL modinvs(LL N, LL mod = 1e9 + 7) {
	vector<LL> inv(N + 1);
	inv[1] = 1;
	LL sinv = 1;
	for (int n = 2; n <= N; n++) {
		inv[n] = mod - (inv[mod % n] * (mod / n)) % mod;
		sinv = (sinv * inv[n]) % mod;
	}
	return PLL(inv[N], sinv);
}

long long Comb(long long n, long long k, vector<long long>& st, vector<long long>& sinv, long long mod = 1e9 + 7) {
	if (n < 0)return 0;
	if (k > n || k < 0)return 0;
	long long ans = st[n];
	ans = (ans * sinv[n - k]) % mod;
	ans = (ans * sinv[k]) % mod;
	return ans;
}

LL Comb(LL N, LL K, LL mod = 1e9 + 7) {
	if (N < 0)return 0;
	if (K > N || K < 0)return 0;
	if (K == 0 || K == N)return 1;
	LL ans = stair(N, mod);
	ans = (ans * modinvs(N - K).second) % mod;
	ans = (ans * modinvs(K).second) % mod;
	return ans;
}

LL powa(LL base, LL p) {
	if (p == 0)return 1;
	if (p == 1)return base;
	LL ans = powa(base, p >> 1);
	ans *= ans;
	ans %= MOD;
	if (p & 1) {
		ans *= base;
		ans %= MOD;
	}
	return ans;
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	LL N, M, K;
	cin >> N >> M >> K;
	LL ans = 0;
	VLL st, inv, sinv;
	stairs(N, st,MOD);
	modinvs(N, inv, sinv, MOD);
	for (LL k = K; k >= 0; k--) {
		LL temp = powa(M-1, N-k-1);
		temp *= Comb(N - 1, k, st, sinv, MOD);
		temp %= MOD;
		ans += temp;
	}
	ans %= MOD;
	ans = (ans * M) % MOD;
	cout << ans << "\n";
	return 0;
}


Measured memory_bytes: 7564