#include <bits/stdc++.h>

using namespace std;

#define all(container)     (container).begin(), container.end()
#define rall(container)    (container).begin(), container.end()
#define sz(container)      (int) (container).size()

using ll = long long;

#ifdef LOCAL_DEFINE
    #include "DEBUG.hpp"
#else
    #define debug(...) 0
#endif
template<class T> bool uin(T &a, T b) { return a > b ? (a = b, true) : false; }
template<class T> bool uax(T &a, T b) { return a < b ? (a = b, true) : false; } 

int Mod = 998244353;
class Modular {
private:
    int value;
    static int mod_inverse(int a, int mod) {
        a %= mod;
        assert(a);
        if (a == 1)
            return 1;
        return int(mod - ll(mod_inverse(mod, a)) * ll(mod) / a);
    }
public:
    Modular(): value(0) {}
    Modular(ll val):value(val % Mod) { if (value < 0) value += Mod;}
    friend std::ostream& operator << (std::ostream& out, const Modular& n) {return out << n.value;}
    friend std::istream& operator >> (std::istream& in, Modular& n) {ll v; in >> v; n = Modular(v); return in;}

    friend bool operator == (const Modular& a, const Modular& b) {return a.value == b.value;}
    friend bool operator != (const Modular& a, const Modular& b) {return a.value != b.value;}

    Modular inverse() const {
        Modular ret;
        ret.value = mod_inverse(this->value, Mod);
        return ret;
    }
    Modular neg() const {
        Modular ret;
        ret.value = this->value ? Mod - this->value : 0;
        return ret;
    }
    Modular operator- (){return neg();}
    Modular& operator++ () {this->value++; if (this->value == Mod) this->value = 0; return *this;}
    Modular& operator-- () {if (this->value == 0) this->value = Mod; --this->value; return *this;}
    Modular& operator+= (const Modular& other) {this->value += other.value; if (this->value >= Mod) this->value -= Mod; return *this;}
    Modular& operator-= (const Modular& other) {this->value -= other.value; if (this->value < 0) this->value += Mod; return *this;}
    Modular& operator*= (const Modular& other) {this->value = ll(this->value) * ll(other.value) % Mod; return *this;}    
    Modular& operator/= (const Modular& other) {return *this *= other.inverse();}
    friend Modular operator ++ (Modular& a, int) {Modular ret = a; ++a; return ret;}
    friend Modular operator -- (Modular& a, int) {Modular ret = a; --a; return ret;}
    friend Modular operator + (const Modular& a, const Modular& b) {Modular ret = a; ret += b; return ret;}
    friend Modular operator - (const Modular& a, const Modular& b) {Modular ret = a; ret -= b; return ret;}
    friend Modular operator * (const Modular& a, const Modular& b) {Modular ret = a; ret *= b; return ret;}
    friend Modular operator / (const Modular& a, const Modular& b) {Modular ret = a; ret /= b; return ret;}
};
using Mint = Modular;

const int maxn = 2e5 + 1;
vector<Mint> fact(maxn);


template<typename T1, typename T2>
T1 epow(T1 a, T2 b) {
    assert(b >= 0);
    T1 ret = 1;
    while (b) {
        if (b & 1)
            ret *= a;
        a *= a;
        b >>= 1;
    }
    return ret;
}

Mint choose(int n, int r) {
    Mint ret;
    Mint temp = fact[n - r] * fact[r];
    return fact[n] * temp.inverse();
}

int main(void) {
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    Mint ans;
    int n, m, k;
    cin >> n >> m >> k;
    fact[0] = 1;
    for (int i = 1; i < maxn; i++) 
        fact[i] = i * fact[i - 1];
    for (int i = 0; i <= k; i++) {
        ans += choose(n - 1, i) * m * epow<Mint, int>(m - 1, n - i - 1);
    }
    cout << ans << '\n';
    return 0;
}

Measured memory_bytes: 3884