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

#include <iostream>
using namespace std;

class ModInt
{
public:
    static int _BM;
    long long int m_value;
    ModInt()
    {
        m_value = 0;
    }

    ModInt(int v)
    {
        m_value = (long long int) v;
    }

    ModInt& operator += ( int v )
    {
        m_value += v;
        if(m_value >= _BM) m_value -= _BM;
        return *this;
    }

    ModInt& operator -= ( int v )
    {
        m_value -= v;
        if( m_value < 0 ) m_value += _BM;
        return *this;
    }

    ModInt& operator *= ( int v )
    {
        m_value *= v;
        m_value %= _BM;
        return *this;
    }

    static int modadd( int a, int b )
    {
        ModInt t(a);
        t += b;
        return t.getint();
    }

    static int modmul( int a, int b )
    {
        ModInt t(a);
        t *= b;
        return t.getint();
    }

    // a^b;
    static int modpow(int a, int b)
    {
        ModInt ans(1);
        int heap[32];
        heap[0] = a;
        for( int bit = 0; b >= (1 << bit); bit++ )
        {
            if( bit > 0 ) heap[bit] = modmul( heap[bit - 1], heap[bit - 1] );
            if( b & (1 << bit) )
            {
                ans *= heap[bit];
            }
        }
        return ans.getint();
    }

    static int reciprocal(int a)
    {
        return modpow(a, _BM - 2);
    }

    static int combination(int n, int r)
    {
        int *fac = (int *)malloc(sizeof(int) * (n + 1));
        int *facinv = (int *)malloc(sizeof(int) * (n + 1));
        fac[0] = 1;
        for( int k = 1; k <= n; k++) fac[k] = modmul(k, fac[k - 1]);
        facinv[n] = reciprocal( fac[n] );
        for( int k = n ; k > 0; k--) facinv[k - 1] = modmul(k, facinv[k]);

        ModInt ans(fac[n]);
        ans *= facinv[r];
        ans *= facinv[n - r];

        free(fac);
        free(facinv);
        return ans.getint();
    }

    int getint()
    {
        return (int) m_value;
    }


private:
    void _mod()
    {
        if( m_value < 0 ) 
        m_value %= _BM;
    }
};

class ModFactorial
{
public:
    int m_max;
    int *m_factorial;
    int *m_factorialinv;

    ModFactorial(int max)
    {
        m_max = max;
        m_factorial = (int*) malloc(sizeof(int) * m_max );
        m_factorialinv = (int*) malloc(sizeof(int) * m_max );
 
        m_factorial[0] = 1;
        for( int k = 1; k < m_max; k++) m_factorial[k] = ModInt::modmul(k, m_factorial[k - 1]);
        m_factorialinv[m_max - 1] = ModInt::reciprocal( m_factorial[m_max - 1] );
        for( int k = m_max - 1 ; k > 0; k--) m_factorialinv[k - 1] = ModInt::modmul(k, m_factorialinv[k]);
    }

    ~ModFactorial()
    {
        free(m_factorial);
        free(m_factorialinv);
    }

    int getFactorial(int n)
    {
        
        return m_factorial[n];
    }

    int getCombination(int n, int r)
    {
        ModInt ans(m_factorial[n]);
        ans *= m_factorialinv[r];
        ans *= m_factorialinv[n - r];
        return ans.getint();
    }
};

int ModInt::_BM = 998244353;

int main()
{
    int n, m, k;
    cin >> n >> m >> k;
    ModInt ans(0);
    ModFactorial gf(n);

    for( int i = 0; i <= k; i++)
    {
        ModInt t(gf.getCombination(n - 1, i));
        t *= m;
        t *= ModInt::modpow(m - 1, n - 1 - i);
        ans += t.getint();
    }

    cout << ans.getint();
}



Measured memory_bytes: 4804