output_description: Print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M K
attempt: import sys
  
  read = sys.stdin.buffer.read
  readline = sys.stdin.buffer.readline
  readlines = sys.stdin.buffer.readlines
  sys.setrecursionlimit(10**7)
  
  
  class Combination:
      def __init__(self, n_max, mod=10**9 + 7):
          # O(n_max + log(mod))
          self.mod = mod
          f = 1
          self.fac = fac = [f]
          for i in range(1, n_max + 1):
              f = f * i % mod
              fac.append(f)
          f = pow(f, mod - 2, mod)
          self.facinv = facinv = [f]
          for i in range(n_max, 0, -1):
              f = f * i % mod
              facinv.append(f)
          facinv.reverse()
  
      # "n 要素" は区別できる n 要素
      # "k グループ" はちょうど k グループ
  
      def __call__(self, n, r):  # self.C と同じ
          return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
  
      def C(self, n, r):
          if not 0 <= r <= n:
              return 0
          return self.fac[n] * self.facinv[r] % self.mod * self.facinv[n - r] % self.mod
  
      def P(self, n, r):
          if not 0 <= r <= n:
              return 0
          return self.fac[n] * self.facinv[n - r] % self.mod
  
      def H(self, n, r):
          if (n == 0 and r > 0) or r < 0:
              return 0
          return (
              self.fac[n + r - 1]
              * self.facinv[r]
              % self.mod
              * self.facinv[n - 1]
              % self.mod
          )
  
      def rising_factorial(self, n, r):  # 上昇階乗冪 n * (n+1) * ... * (n+r-1)
          return self.fac[n + r - 1] * self.facinv[n - 1] % self.mod
  
      def stirling_first(
          self, n, k
      ):  # 第 1 種スターリング数  lru_cache を使うと O(nk)  # n 要素を k 個の巡回列に分割する場合の数
          if n == k:
              return 1
          if k == 0:
              return 0
          return (
              self.stirling_first(n - 1, k - 1) + (n - 1) * self.stirling_first(n - 1, k)
          ) % self.mod
  
      def stirling_second(
          self, n, k
      ):  # 第 2 種スターリング数 O(k + log(n))  # n 要素を区別のない k グループに分割する場合の数
          if n == k:
              return 1  # n==k==0 のときのため
          return (
              self.facinv[k]
              * sum(
                  (-1) ** (k - m) * self.C(k, m) * pow(m, n, self.mod)
                  for m in range(1, k + 1)
              )
              % self.mod
          )
  
      def balls_and_boxes_3(
          self, n, k
      ):  # n 要素を区別のある k グループに分割する場合の数  O(k + log(n))
          return (
              sum(
                  (-1) ** (k - m) * self.C(k, m) * pow(m, n, self.mod)
                  for m in range(1, k + 1)
              )
              % self.mod
          )
  
      def bernoulli(self, n):  # ベルヌーイ数  lru_cache を使うと O(n**2 * log(mod))
          if n == 0:
              return 1
          if n % 2 and n >= 3:
              return 0  # 高速化
          return (
              -pow(n + 1, self.mod - 2, self.mod)
              * sum(self.C(n + 1, k) * self.bernoulli(k) % self.mod for k in range(n))
          ) % self.mod
  
      def faulhaber(self, k, n):  # べき乗和 0^k + 1^k + ... + (n-1)^k
          # bernoulli に lru_cache を使うと O(k**2 * log(mod))  bernoulli が計算済みなら O(k * log(mod))
          return (
              pow(k + 1, self.mod - 2, self.mod)
              * sum(
                  self.C(k + 1, j)
                  * self.bernoulli(j)
                  % self.mod
                  * pow(n, k - j + 1, self.mod)
                  % self.mod
                  for j in range(k + 1)
              )
              % self.mod
          )
  
      def lah(self, n, k):  # n 要素を k 個の空でない順序付き集合に分割する場合の数  O(1)
          return self.C(n - 1, k - 1) * self.fac[n] % self.mod * self.facinv[k] % self.mod
  
      def bell(
          self, n, k
      ):  # n 要素を k グループ以下に分割する場合の数  O(k**2 + k*log(mod))
          return sum(self.stirling_second(n, j) for j in range(1, k + 1)) % self.mod
  
  
  n, m, k = map(int, read().split())
  mod = 998244353
  comb = Combination(n, mod)
  ans = 0
  n -= 1
  for i in range(k + 1):
      ans += comb.C(n, n - i) * m * pow(m - 1, n - i, mod) % mod
      ans %= mod
  print(ans)
  
problem_description: 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.
samples: [{"input": "3 2 1", "output": "6\n    \n\nThe following ways to paint the blocks satisfy the conditions: `112`, `121`,\n`122`, `211`, `212`, and `221`. Here, digits represent the colors of the\nblocks.\n\n* * *"}, {"input": "100 100 0", "output": "73074801\n    \n\n* * *"}, {"input": "60522 114575 7559", "output": "479519525"}]