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

typedef long long ll;
typedef unsigned long long ull;

class ModInt{
public:
    ModInt(){
        x = 0;
    }
    ModInt(int v){
        x = (((v % mod) + mod) % mod);
    }
    ModInt(long long v){
        x = (((v % mod) + mod) % mod);
    }

    ModInt operator-() const {return ModInt(-x);}
    ModInt& operator+=(const ModInt& a){
        x = (x + a.x) % mod;
        return *this;
    }
    ModInt& operator-=(const ModInt& a){
        x = (x + mod - a.x) % mod;
        return *this;
    }
    ModInt& operator*=(const ModInt& a){
        x = (x * a.x) % mod;
        return *this;
    }
    ModInt operator+(const ModInt& a) const{
        ModInt res(*this);
        res += a;
        return res;
    }
    ModInt operator-(const ModInt& a) const{
        ModInt res(*this);
        res -= a;
        return res;
    }
    ModInt operator*(const ModInt& a) const{
        ModInt res(*this);
        res *= a;
        return res;
    }
    ModInt power(long long a) const{
        if(a == 0) return 1;
        auto b = power(a >> 1);
        b *= b;
        if(a & 1) b *= *this;
        return b;
    }
    ModInt inverse() const{
        return power(mod - 2);
    }
    ModInt& operator/=(const ModInt& a){
        (*this) *= a.inverse();
        return *this;
    }
    ModInt operator/(const ModInt& a)const{
        ModInt res(*this);
        res /= a;
        return res;
    }
    friend ostream& operator<<(ostream& os, const ModInt& a){
        os << a.x;
        return os;
    }

    static ModInt add(long long a, long long b){
        ModInt res(a);
        res += b;
        return res;
    }

    static long long get_mod(){ return mod;}

private:
    static const long long mod = 998244353;
    long long x;
};

class FastCombination{
public:
    FastCombination(int n){
        auto mod = ModInt::get_mod();
        m_fac  = vector<ModInt>(n);
        m_finv = vector<ModInt>(n);
        m_inv  = vector<ModInt>(n);

        m_fac[0] = 1;
        m_fac[1] = 1;
        m_finv[0] = 1;
        m_finv[1] = 1;
        m_inv[1] = 1;
        for(int i=2; i<n; i++){
            m_fac [i] = m_fac[i-1] * i;
            m_inv [i] =-m_inv[mod%i] * (mod / i);
            m_finv[i] = m_finv[i-1] * m_inv[i];
        }
    }

    ModInt calc(int n, int k){
        if(n<k) return 0;
        if(n<0 || k<0) return 0;
        return m_fac[n] * m_finv[k] * m_finv[n-k];
    }

private:
    vector<ModInt> m_fac;
    vector<ModInt> m_finv;
    vector<ModInt> m_inv;
};

ModInt combination(long long n, long long k){
    ModInt res(1);
    if(k > n - k) k = n - k;
    for(long long i=0; i<k; i++){
        res *= n - i;
        res /= i + 1;
    }
    return res;
}

ModInt multi_combination(long long n, long long k){
    return combination(n + k - 1, k);
}


int main()
{
    ll N, M, K;
    cin >> N >> M >> K;

    // (M-1)^(N-1-k)
    vector<ll> memo(N);
    ll tmp = 1;
    for(int k=0; k<N; k++){
        memo[k] = tmp;
        tmp *= (M-1);
        tmp %= 998244353;
    }

    ModInt res;
    auto fc = FastCombination(N);
    for(int k=0; k<=K; k++){
        res += fc.calc(N-1, k) * M * ModInt(memo[(N-1)-k]);
    }
    cout << res << endl;

    return 0;
}


Measured memory_bytes: 9444