#pragma GCC optimize("Ofast,inline,unroll-loops,fast-math")
#include <iostream>
#include <algorithm>
#include <cstdio>
#define N 524289
#define MOD 998244353
using namespace std;

extern int Power(int x, int y);

namespace Comb
{
    int f[N], g[N];

    void Init(int n)
    {
        int i;

        for(i = f[0] = 1; i <= n; i ++)
            f[i] = (long long)f[i - 1] * i % MOD;
        g[n] = Power(f[n], MOD - 2);
        for(i = n - 1; i >= 0; i --)
            g[i] = (long long)g[i + 1] * (i + 1) % MOD;

        return;
    }

    int C(int n, int m)
    {
        return (long long)f[n] * g[m] % MOD * g[n - m] % MOD;
    }
}

namespace NTT
{
    int f[N], g[N];
    int w[2][N], r[N];

    void ExGCD(int a, int b, int &x, int &y)
    {
        if(!b)
        {
            x = 1;
            y = 0;
        }
        else
        {
            ExGCD(b, a % b, y, x);
            y -= x * (a / b);
        }

        return;
    }

    int Inverse(int k)
    {
        int x, y;

        ExGCD(k, MOD, x, y);

        return (x % MOD + MOD) % MOD;
    }

    int InitNTT(int n)
    {
        int i, j, c;

        for(c = 0; (1 << c) < n; c ++)
            ;
        for(i = 0; i < (1 << c); i ++)
            for(j = r[i] = 0; j < c; j ++)
                if(i & (1 << j))
                    r[i] |= 1 << (c - j - 1);

        w[0][0] = w[1][0] = 1;
        w[0][1] = Power(3, (MOD - 1) >> c);
        w[1][1] = Inverse(w[0][1]);
        for(i = 2; i < (1 << c); i ++)
        {
            w[0][i] = (long long)w[0][i - 1] * w[0][1] % MOD;
            w[1][i] = Inverse(w[0][i]);
        }

        return c;
    }

    void NTT(int *f, int n, int *w)
    {
        int i, j, l;
        int k;

        for(i = 0; i < n; i ++)
            if(i < r[i])
                swap(f[i], f[r[i]]);

        for(l = 0; (1 << l) < n; l ++)
            for(i = 0; i < n; i += 1 << (l + 1))
                for(j = 0; j < (1 << l); j ++)
                {
                    k = (long long)f[i + j + (1 << l)] * w[(n >> l >> 1) * j] % MOD;
                    f[i + j + (1 << l)] = (f[i + j] - k) % MOD;
                    f[i + j] = (f[i + j] + k) % MOD;
                }

        return;
    }

    void DFT(int *f, int n)
    {
        NTT(f, n, w[0]);

        return;
    }

    void IDFT(int *f, int n)
    {
        int i, k;

        NTT(f, n, w[1]);
        k = Inverse(n);

        for(i = 0; i < n; i ++)
            f[i] = (long long)(f[i] + MOD) % MOD * k % MOD;

        return;
    }
}

int f[N], g[N];

int Power(int x, int y)
{
    int o;

    for(o = 1; y; y >>= 1)
    {
        if(y & 1)
            o = (long long)o * x % MOD;
        x = (long long)x * x % MOD;
    }

    return o;
}

int main(void)
{
    int n, m, k;
    int i, c, o;

    Comb::Init(N - 1);
    cin >> n >> m >> k;

    for(i = 0; i < n; i ++)
        f[i] = (long long)Comb::C(n - 1, i) * Power(m, n - i) % MOD;

    for(i = 0; i < n; i ++)
    {
        NTT::f[i] = ((i & 1 ? -1 : 1) * Comb::g[i] + MOD) % MOD;
        NTT::g[i] = (long long)f[n - 1 - i] * Comb::f[n - 1 - i] % MOD;
    }

    c = NTT::InitNTT(n * 2 - 1);

    NTT::DFT(NTT::f, 1 << c);
    NTT::DFT(NTT::g, 1 << c);
    for(i = 0; i < (1 << c); i ++)
        NTT::f[i] = (long long)NTT::f[i] * NTT::g[i] % MOD;
    NTT::IDFT(NTT::f, 1 << c);

    for(i = o = 0; i <= k; i ++)
        o = (o + (long long)NTT::f[n - 1 - i] * Comb::g[i] % MOD) % MOD;
    cout << o << endl;

    return 0;
}


Measured memory_bytes: 18712