#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <map>
#include <assert.h>
#include <stack>
#include <queue>
#include <deque>
#include <list>
#include <set>
#include <bitset>
#include <numeric>
#include <string.h>
#include <utility>

using namespace std;
#define IO                 \
	ios::sync_with_stdio(0); \
	cin.tie(0);              \
	cout.tie(0);
#define sz(x) (int)((x).size())
#define forn(i,n) for (int i=0; i < n; i++)
#define forse(i,s,e) for (int i=s; i < e; i++)
#define pb push_back 
#define pf push_front
#define rb pop_back
#define rf pop_front
#define mp make_pair
#define fi first
#define se second
#define all(vec) vec.begin(), vec.end()
#define time() ((double)clock() / CLOCKS_PER_SEC)
#define debug(x) cerr << (#x) << " is " << (x) << endl;

#ifndef LOCAL
#define cerr if(false)cerr
#endif

typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll P=998244353;
double PI=3.141592653589793;
const int arrn = 2e5 + 1;


class mint{
	public:
		static int init_siz;
		static vector<mint> inverse,factorial;
		static int mintP;
		int n;
		static mint exp(mint a, long long e) {
			mint res = 1; while (e) { if (e&1) res *= a; a *= a; e >>= 1; }
			return res;
		}
		static void init(int n){
			init_siz=n;
			inverse.resize(n+1);factorial.resize(n+1);
			factorial[0] = 1;
			for (int i = 1; i <= n; i++) factorial[i] = factorial[i - 1] * i;
			inverse[n]=exp(factorial[n],mintP-2);
			for (int i = n-1; i>=0; i--) inverse[i] = inverse[i+1] * (i+1);
		}
		static mint inv(mint const& a){return (init_siz>=a.n? inverse[a.n]:exp(a,mintP-2));}
		static mint fac(mint const& a){
			if(init_siz>=a.n) return factorial[a.n];
			else{
				mint out=1;
				for(int i=0;i<a.n;i++) out*=(i+1);
				return out;
			}
		}
		mint(long long val = 0) {n=val%mintP;if(n<0) n+=mintP;}
		mint& operator+=(mint const& b) {n += b.n; if (n >= mintP) n -= mintP; return *this;}
		mint& operator-=(mint const& b) {n -= b.n; if (n < 0) n += mintP;return *this;}
		mint& operator*=(mint const& b) {n = (long long)n * b.n % mintP;return *this;}
		mint exp(long long e) {return exp(*this,e);}
		mint inv(){return inv(*this);}
		mint& operator/=(mint const& b){ return *this *=inv(b);}	
		friend std::ostream& operator<<(std::ostream& os,mint const& a) {return os << (a.n<0?a.n+mintP:a.n);}
		friend mint operator+(mint a, mint const b) { return a += b; }
		friend mint operator-(mint a, mint const b) { return a -= b; }
		friend mint operator-(mint const a) { return 0 - a; }
		friend mint operator*(mint a, mint const b) { return a *= b; }
		friend mint operator/(mint a, mint const b) { return a /= b; }
		friend bool operator==(mint const& a, mint const& b) {return a.n == b.n;}
		friend bool operator!=(mint const& a, mint const& b) {return a.n != b.n;}
};
int mint::init_siz=0;
int mint::mintP=P;
vector<mint> mint::factorial,mint::inverse;

mint comb(int n,int r) {
	if (n < r)
		return 0;
	else {
		return (mint::fac(n)*mint::inv(r)*mint::inv(n-r));
	}
}

void solve(){
	int n,m,k;
	cin >> n >> m >> k;
	mint ans=0;
	forse(i,n-k,n+1){
		ans+=mint::exp(m-1,i-1)*comb(n-1,n-i);
	//	cout << ans << '\n';
	}
	ans*=m;
	cout << ans;
}

int main() {
	mint::init(2e5+5);
	IO;
	int T=1;
//	cin >> T;
	forn(c,T){
		solve();
	}
}



Measured memory_bytes: 4692