#include <algorithm>
#include <array>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <set>
#include <string>
#include <string_view>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;

int64_t read_int() {
    int64_t ret = 0, sgn = 1;
    int ch = getchar_unlocked();
    while (isspace(ch)) { ch = getchar_unlocked(); }
    if (ch == '-') { sgn = -1; ch = getchar_unlocked(); }
    for (; isdigit(ch); ch = getchar_unlocked())
        ret = (ret * 10) + (ch - '0');
    ungetc(ch, stdin);
    return sgn * ret;
}

#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define ALL(c) (c).begin(), (c).end()

template <typename T> inline void assign_min(T& x, const T& value) noexcept { x = min(x, value); }
template <typename T> inline void assign_max(T& x, const T& value) noexcept { x = max(x, value); }

constexpr char LF = '\n';

//-------------------------------------------------------------------------------------------------
#include <boost/operators.hpp>

// a を m で割った余り(>=0)を返す。
constexpr inline int mod(int a, int m) noexcept {
    int r = a % m;
    return r < 0 ? r + m : r;
}

// ax + by = gcd(a, b) を満たすような整数 x,y を返す。
template<int MOD>
pair<int64_t, int64_t> exgcd(int a, int b) noexcept {
    if (b == 0) return {1, 0};
    auto [x, y] = exgcd<MOD>(b, a%b);
    return {y, x-(a/b)*y};
}

// a の逆元を返す。a は MOD と互いに素でなければならない。
template<int MOD>
inline int inverse(int a) noexcept {
    return mod(exgcd<MOD>(MOD, a).second, MOD);
}

template<int MOD>
struct ModInt : private boost::operators<ModInt<MOD>> {
    int value;
    constexpr ModInt() noexcept : value(0) {}
    constexpr ModInt(int value) noexcept : value(mod(value, MOD)) {}
    constexpr ModInt<MOD>& operator+=(const ModInt<MOD>& rhs) noexcept {
        value += rhs.value;
        if (value > MOD) value -= MOD;
        return *this;
    }
    constexpr ModInt<MOD>& operator-=(const ModInt<MOD>& rhs) noexcept {
        value -= rhs.value;
        if (value < 0) value += MOD;
        return *this;
    }
    constexpr ModInt<MOD>& operator*=(const ModInt<MOD>& rhs) noexcept {
        value = ((int64_t)value * rhs.value) % MOD;
        return *this;
    }
    ModInt<MOD>& operator/=(const ModInt<MOD>& rhs) noexcept {
        return *this *= rhs.inverse();
    }
    constexpr bool operator<(const ModInt<MOD>& rhs) const noexcept {
        return value < rhs.value;
    }
    constexpr bool operator==(const ModInt<MOD>& rhs) const noexcept {
        return value == rhs.value;
    }
    ModInt<MOD> pow(int64_t n) const noexcept {
        auto a = *this;
        auto ans = ModInt<MOD>(1);
        while (n > 0) {
            if (n & 1) ans *= a;
            a *= a;
            n >>= 1;
        }
        return ans;
    }
    ModInt<MOD> inverse() const noexcept {
        return ModInt<MOD>(::inverse<MOD>(value));
    }
};
template<int MOD>
ostream& operator<<(ostream& os, const ModInt<MOD>& rhs) {
    os << rhs.value;
    return os;
}
template<int MOD>
istream& operator>>(istream& is, ModInt<MOD>& rhs) {
    int i; is >> i;
    rhs.value = mod(i, MOD);
    return is;
}

template<class Int>
struct Combination {
    vector<Int> facts = {1};
    vector<Int> inv_facts;
    Int fact(int n) {
        if (n < (int)facts.size()) { return facts[n]; }
        for (int i = facts.size(); i <= n; ++i) {
            facts.emplace_back(facts[i-1] * i);
        }
        return facts[n];
    }
    Int inv_fact(int n) {
        if (n < (int)inv_facts.size()) { return inv_facts[n]; }
        fact(n); // fill facts[0..n]
        for (int i = inv_facts.size(); i <= n; ++i) {
            inv_facts.emplace_back(facts[i].inverse());
        }
        return inv_facts[n];
    }
    Int nCr(int n, int r) { return fact(n) * inv_fact(r) * inv_fact(n-r); }
    Int nHr(int n, int r) { return nCr(n+r-1, r); }
};

using mint = ModInt<998244353>;

int main() {
    Combination<mint> cmb;

    int N = read_int();
    mint M = mint(read_int());
    int K = read_int();

    mint ans;
    REP(k, K+1) {
        // N-k 個の色を隣り合わないように塗る
        auto a = M * (M-1).pow(N-k-1);
        // 重複を許して N-k 個から k 個選ぶ
        auto b = cmb.nHr(N-k, k);
        ans += a * b;
    }
    cout << ans << LF;
}


Measured memory_bytes: 5048