#include <algorithm>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define all(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
constexpr ll INF = 1ll << 55;

template <typename T> inline constexpr bool chmin(T &a, T b) {
  if (b < a) {
    a = b;
    return true;
  }
  return false;
}
template <typename T> inline constexpr bool chmax(T &a, T b) {
  if (b > a) {
    a = b;
    return true;
  }
  return false;
}

// multi-dimensional vector (require c++14)
template <typename T, typename U>
static inline vector<U> make_nd_vector(T &&n, U &&val) noexcept {
  static_assert(is_integral<T>::value,
                "[make_nd_vector] 1st argument must be an integer type");
  return vector<U>(forward<T>(n), forward<U>(val));
}
template <typename T, typename... Args>
static inline decltype(auto) make_nd_vector(T &&n, Args &&... args) noexcept {
  static_assert(is_integral<T>::value,
                "[make_nd_vector] 1st argument must be an integer type");
  return vector<decltype(make_nd_vector(forward<Args>(args)...))>(
      forward<T>(n), make_nd_vector(forward<Args>(args)...));
}
//
// Print from Iterator
template <typename ite>
void print_ite(ite start, ite end, char sp = ' ', char en = '\n') {
  for (auto i = start; i != end; i++)
    cout << *i << sp;
  cout << en;
}
//
inline void Yes(bool condition) { cout << (condition ? "Yes\n" : "No\n"); }

namespace mod {
using u64 = uint_fast64_t;
template <uint_fast64_t MOD> class modInt {

private:
  u64 a;

public:
  constexpr modInt(const long long x = 0) : a(((x % MOD) + MOD) % MOD) {}
  constexpr inline u64 value() const { return a; }
  constexpr modInt pow(u64 p) const {
    if (p == 0)
      return modInt(1);
    if (p % 2 == 0) {
      modInt d = pow(p / 2);
      return d * d;
    } else {
      return *this * pow(p - 1);
    }
  }
  constexpr modInt inverse() const { return pow(MOD - 2); }
  constexpr modInt &operator+=(const modInt x) {
    a += x.a;
    if (a >= MOD) {
      a -= MOD;
    }
    return *this;
  }
  constexpr modInt &operator-=(const modInt x) {
    if (a < x.a) {
      a += MOD;
    }
    a -= x.a;
    return *this;
  }
  constexpr modInt &operator*=(const modInt x) {
    a = a * x.a % MOD;
    return *this;
  }
  constexpr modInt &operator/=(const modInt x) {
    assert(x.a != 0);
    *this *= x.inverse();
    return *this;
  }
  constexpr modInt operator++() { return *this += modInt(1); }
  constexpr modInt operator--() { return *this -= modInt(1); }
};
template <u64 MOD>
constexpr modInt<MOD> operator+(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) += rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator-(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) -= rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator*(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) *= rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator/(const modInt<MOD> lha, const modInt<MOD> rha) {
  return modInt<MOD>(lha) /= rha;
}
template <u64 MOD>
constexpr modInt<MOD> operator==(const modInt<MOD> lha, const modInt<MOD> rha) {
  return lha.value() == rha.value();
}
template <u64 MOD>
constexpr modInt<MOD> operator!=(const modInt<MOD> lha, const modInt<MOD> rha) {
  return !(lha.value() == rha.value());
}
template <u64 MOD>
std::ostream &operator<<(std::ostream &stream, const modInt<MOD> x) {
  stream << x.value();
  return stream;
}
template <u64 MOD>
std::istream &operator>>(std::istream &stream, modInt<MOD> &x) {
  u64 a;
  stream >> a;
  x = modInt<MOD>(a);
  return stream;
}
} // namespace mod
template <long long MOD> class Combination_calcurator {
  using ll = long long;
  using modint = mod::modInt<MOD>;

private:
  std::vector<modint> fac;
  std::vector<modint> facinv;

public:
  Combination_calcurator(ll max) : fac(max + 1), facinv(max + 1) {
    fac[0] = 1;
    for (int i = 1; i <= max; i++) {
      fac[i] = fac[i - 1] * modint(i);
    }
    facinv[max] = fac[max].inverse();
    for (int i = max - 1; i >= 0; i--) {
      facinv[i] = facinv[i + 1] * modint(i + 1);
    }
  }
  modint calc(ll n, ll r) {
    if (n < r)
      return 0;
    if (n < 0 || r < 0)
      return 0;
    return fac[n] * facinv[r] * facinv[n - r];
  }
};

constexpr ll MOD = 998244353;
using modint = mod::modInt<MOD>;
int main() {
  modint m;
  int n, k;
  cin >> n >> m >> k;
  auto com = Combination_calcurator<MOD>(n + 20);
  auto ans = modint(0);
  for (int i = 0; i <= k; i++) {
    ans += m * (m - modint(1)).pow(n - i - 1) * com.calc(n - 1, i);
  }
  cout << ans << endl;
}


Measured memory_bytes: 6052