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 Common Lisp (SBCL 2.0.3) (judge verdict: Time Limit Exceeded)

;(load "lib.lisp")
(declaim (optimize (speed 3) (safety 0) (debug 0)))
#+sbcl (declaim (sb-ext:muffle-conditions sb-ext:compiler-note))
(defconstant +modulo+ 998244353)

(defun expt-mod (b e m)
  (declare (type fixnum b e m))
  (loop with aa fixnum = 1
	with bb fixnum = b
	with ee fixnum = e
	until (zerop ee) do
	(if (evenp ee)
	    (psetf bb (rem (the fixnum (* bb bb)) m)
		   ee (ash ee -1))
	  (psetf aa (rem (the fixnum (* aa bb)) m)
		 ee (1- ee)))
	finally (return aa)))

(defun count-3 (n m k)
  (declare (type (integer 1 200000) n m))
  (declare (type (integer 0 199999) k))
  (let ((beta (1- m)))
    (loop for kk fixnum from 0 to k
	  for e fixnum in (nreverse (loop for i from 0 below n
				   for e fixnum = 1 then (rem (* e beta) +modulo+)
				   collecting e))
	  for binom = 1 then (/ (* binom (- n kk)) kk)
	  with sum fixnum = 0
	  do
	  (setf sum (rem (+ sum (* binom e)) +modulo+))
	  finally (return (rem (* sum m) +modulo+)))))

(let* ((n (read))
      (m (read))
      (k (read)))
  (princ (count-3 n m k)))