Problem:
Score : 500 points

Problem Statement

There are N blocks arranged in a row. Let us paint these blocks.

We will consider two ways to paint the blocks different if and only if there is a block painted in different colors in those two ways.

Find the number of ways to paint the blocks under the following conditions:

For each block, use one of the M colors, Color 1 through Color M, to paint it. It is not mandatory to use all the colors.

There may be at most K pairs of adjacent blocks that are painted in the same color.

Since the count may be enormous, print it modulo 998244353.

Constraints

All values in input are integers.

1 \leq N, M \leq 2 \times 10^5

0 \leq K \leq N - 1

Input

Input is given from Standard Input in the following format:

N M K

Output

Print the answer.

Sample Input 1

3 2 1

Sample Output 1

6

The following ways to paint the blocks satisfy the conditions: 112, 121, 122, 211, 212, and 221. Here, digits represent the colors of the blocks.

Sample Input 2

100 100 0

Sample Output 2

73074801

Sample Input 3

60522 114575 7559

Sample Output 3

479519525

Solution in Rust (1.42.0) (judge verdict: Wrong Answer)

#![allow(unused)]

//
// Based on EbTech's Scanner https://stackoverflow.com/q/56449027
//
struct Scanner<'a, R: std::io::BufRead> {
    reader: R,
    buf: String,
    iter: std::str::SplitWhitespace<'a>,
}

impl<'a, R: std::io::BufRead> Scanner<'a, R> {
    fn new(reader: R) -> Self {
        Self { reader, buf: String::new(), iter: "".split_whitespace() }
    }

    fn get_str(&mut self) -> &str {
        if let Some(t) = self.iter.next() {
            return t;
        }
        self.buf.clear();
        self.reader.read_line(&mut self.buf).expect("I/O error");
        self.iter = unsafe { std::mem::transmute(self.buf.split_whitespace()) };
        self.get_str()
    }

    fn get<T: std::str::FromStr>(&mut self) -> T {
        self.get_str().parse().ok().expect("Parse error")
    }
}

fn main() {
    let stdin = std::io::stdin();
    solve(Scanner::new(stdin.lock()));
}

const M: i64 = 998244353;

fn mod_inverse(mut a: i64, m: i64) -> i64 {
    use std::mem::swap;

    let mut b = m;
    let mut u = 1;
    let mut v = 0;

    while b > 0 {
        let mut t = a / b;
        a -= t * b;
        swap(&mut a, &mut b);
        u -= t * v;
        swap(&mut u, &mut v);
    }

    u %= m;
    return if u < 0 { u + m } else { u };
}

fn solve<R: std::io::BufRead>(mut sc: Scanner<R>) {
    let n: i64 = sc.get();
    let m: i64 = sc.get();
    let k: i64 = sc.get();

    let m_minus_1_inv = mod_inverse(m - 1, M);
    let ans = (0..=k)
        .scan(
            (0..(n - 1)).fold(m, |a, _| a * (m - 1) % M),
            |a, i| {
                let a_ = *a;
                *a = *a * m_minus_1_inv % M
                        * (n - (i + 1)) % M
                        * mod_inverse(i + 1, M) % M;
                Some(a_)
            })
        .fold(0, |a, x| (a + x) % M);
    println!("{}", ans);
}