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: Accepted)

;(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 make-expt-mod-table (b l u m)
  (let ((a (make-array (+ (abs (- u l)) 1) :element-type 'fixnum)))
    (declare (type (simple-array fixnum (*)) a))
    (if (> u l)
	(loop for e fixnum = (expt-mod b l m) then (rem (the fixnum (* e b)) m)
	      for i fixnum from 0 to (- u l)
	      do (setf (aref a i) e))
      (loop for e fixnum = (expt-mod b u m) then (rem (the fixnum (* e b)) m)
	    for i fixnum from (- l u) downto 0
	    do (setf (aref a i) e)))
    a))

;; nCk = n-1Ck-k + n-1Ck
(defun make-binom-mod-table (n uk m)
  (let ((a (make-array (1+ uk) :element-type 'fixnum)))
    (declare (type (simple-array fixnum (*)) a))
    (setf (aref a 0) 1)
    (loop for nn fixnum from 1 to n do
	  (when (<= nn uk) (setf (aref a nn) 1))
	  (loop for kk fixnum from 1 to (min (1- nn) uk) 
		with temp fixnum = 1 do
		(psetf (aref a kk) (rem (+ temp (aref a kk)) m)
		       temp (aref a kk))))
    a))

;; nCk = (n-k+1)/k nCk-1
(defun make-binom-mod-p-table (n uk p)
  (let ((a (make-array (1+ uk) :element-type 'fixnum)))
    (declare (type (simple-array fixnum (*)) a))
    (setf (aref a 0) 1)
    (loop for kk fixnum from 1 to uk do
	  (setf (aref a kk)
		(rem (* (- n kk -1)
			(aref a (1- kk))
			(expt-mod kk (- p 2) p))
		     p)))
    a))

(defun count-4-a (n m k)
  (declare (type (integer 1 200000) n m))
  (declare (type (integer 0 199999) k))
  (let* ((beta (1- m))
	 (et (make-expt-mod-table beta (1- n) (- n k 1) +modulo+))
	 (bt (make-binom-mod-p-table (1- n) k +modulo+)))
    (declare (type (simple-array fixnum (*)) et bt))
    (loop for e fixnum across et
	  and b fixnum across bt
	  with sum fixnum = 0
	  do (setf sum (rem (the fixnum (+ sum (the fixnum (* e b)))) +modulo+))
	  finally (return (rem (the fixnum (* m sum)) +modulo+)))))

(defun count-4-b (n m k)
  (declare (type (integer 1 200000) n m))
  (declare (type (integer 0 199999) k))
  (when (= (1- n) k)
    (return-from count-4-b (rem (* m (expt-mod m (1- n) +modulo+))
				+modulo+)))
  (let* ((beta (1- m))
	 (et (make-expt-mod-table beta 0 (- n 2 k) +modulo+))
	 (bt (make-binom-mod-p-table (1- n) (- n 2 k) +modulo+)))
    (declare (type (simple-array fixnum (*)) et bt))
    (loop for e fixnum across et
	  and b fixnum across bt
	  with sum fixnum = (expt-mod m (1- n) +modulo+)
	  do (setf sum (mod (the fixnum (- sum (the fixnum (* b e)))) +modulo+))
	  finally (return (rem (the fixnum (* m sum)) +modulo+)))))
	  
(defun count-4 (n m k)
  (if (> k (floor n 2))
      (count-4-b n m k)
    (count-4-a n m k)))

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