Language: C++

#include <bits/stdc++.h>

using namespace std;

#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { std::cout << #a << " = " << a << "\n"; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
template<class T, class V> istream& operator>> (istream& ist, pair<T, V>& p) { return ist >> p.first >> p.second; }
template<class T> ostream& operator<< (ostream& ost, pair<T, T>& p) { return ost << p.first << ", " << p.second; }
template<class T> istream& operator>> (istream& ist, vector<T>& vs) { for(auto& e: vs) ist >> e; return ist; }

typedef long long ll;
int const inf = INT_MAX / 2;

constexpr ll MOD = 998244353;

namespace math { namespace integer {

template<class T> T mod_mul(T x, T k, T m) { if(k == 0) { return 0; } if(k % 2 == 0) { return mod_mul((x + x) % m, k / 2, m); } else { return (x + mod_mul(x, k - 1, m)) % m; } }
template<class T> T mod_pow(T x, T n, T mod) { if(n == 0) { return 1; } if(n % 2 == 0) { return mod_pow(mod_mul(x, x, mod) % mod, n / 2, mod); } else { return mod_mul(x, mod_pow(x, n - 1, mod), mod); } }
template<class T> T extgcd(T a, T b, T& x, T& y) { T d = a; if(b != 0) { d = extgcd(b, a % b, y, x); y -= (a / b) * x;} else { x = 1, y = 0; } return d; }
template<class T> T mod_inverse(T x, T mod) { return mod_pow(x, T(mod - 2), mod); /* use fermat */ }
template<class T> T mod_inverse_composite_num_mod(T a, ll mod) { T x, y; extgcd(a, mod, x, y); return (mod + x % mod) % mod; }

}}
using namespace math::integer;

namespace math {

constexpr int MaxFact = 200020;

template<class T = int64_t>
struct FactRevFactList {
  array<T, MaxFact+1> fact_;
  array<T, MaxFact+1> rev_fact_;

  FactRevFactList() {
    fact_[0] = 1;
    for(int i=1; i<MaxFact; i++) {
      fact_[i] = fact_[i-1] * i;
      fact_[i] %= MOD;
    }

    rev_fact_[MaxFact-1] = mod_pow(fact_[MaxFact-1], (T)MOD-2, MOD);

    for(int i=MaxFact-2; i>=0; i--) {
      rev_fact_[i] = rev_fact_[i+1] * (i+1);
      rev_fact_[i] %= MOD;
    }
  }

  T fact(int x) const { return fact_[x]; }
  T fact_inv(int x) const { return rev_fact_[x]; }
};

template<class T = int64_t>
struct CombinationBig {
  math::FactRevFactList<> fr_;
  T comb(T n, T r) { return (fr_.fact(n) * fr_.fact_inv(r) % MOD) * fr_.fact_inv(n-r) % MOD; }
};

}

math::CombinationBig<> cbig;

int main() {
  ll N, M, K; cin >> N >> M >> K;  
  // k 組, d 個重複
  ll ans = 0;
  int count = 0;
  rep(k, K + 1) rep(d, k + 1) {
    count++;
    if (count >= 1000000000) { assert("TLE" && 0); }
    if (2 * k - d > N) { continue; }
    if (k && k == d) { continue; }
    ans += mod_mul(
      cbig.comb(N - k, k - d),
      mod_pow(M - 1, N - k - 1, MOD),
      MOD
    );
    ans %= MOD;
  }
  ans *= M;
  ans %= MOD;
  cout << ans << endl;
}


Compiler output:
a.cc: In function 'int main()':
a.cc:81:19: error: no matching function for call to 'mod_mul(long int, long long int, const ll&)'
   81 |     ans += mod_mul(
      |            ~~~~~~~^
   82 |       cbig.comb(N - k, k - d),
      |       ~~~~~~~~~~~~~~~~~~~~~~~~
   83 |       mod_pow(M - 1, N - k - 1, MOD),
      |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   84 |       MOD
      |       ~~~          
   85 |     );
      |     ~              
a.cc:24:21: note: candidate: 'template<class T> T math::integer::mod_mul(T, T, T)'
   24 | template<class T> T mod_mul(T x, T k, T m) { if(k == 0) { return 0; } if(k % 2 == 0) { return mod_mul((x + x) % m, k / 2, m); } else { return (x + mod_mul(x, k - 1, m)) % m; } }
      |                     ^~~~~~~
a.cc:24:21: note:   template argument deduction/substitution failed:
a.cc:81:19: note:   deduced conflicting types for parameter 'T' ('long int' and 'long long int')
   81 |     ans += mod_mul(
      |            ~~~~~~~^
   82 |       cbig.comb(N - k, k - d),
      |       ~~~~~~~~~~~~~~~~~~~~~~~~
   83 |       mod_pow(M - 1, N - k - 1, MOD),
      |       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   84 |       MOD
      |       ~~~          
   85 |     );
      |     ~              
a.cc: In instantiation of 'math::FactRevFactList<T>::FactRevFactList() [with T = long int]':
a.cc:62:8:   required from here
   62 | struct CombinationBig {
      |        ^~~~~~~~~~~~~~
a.cc:49:35: error: no matching function for call to 'mod_pow(std::array<long int, 200021>::value_type&, long int, const ll&)'
   49 |     rev_fact_[MaxFact-1] = mod_pow(fact_[MaxFact-1], (T)MOD-2, MOD);
      |                            ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
a.cc:25:21: note: candidate: 'template<class T> T math::integer::mod_pow(T, T, T)'
   25 | template<class T> T mod_pow(T x, T n, T mod) { if(n == 0) { return 1; } if(n % 2 == 0) { return mod_pow(mod_mul(x, x, mod) % mod, n / 2, mod); } else { return mod_mul(x, mod_pow(x, n - 1, mod), mod); } }
      |                     ^~~~~~~
a.cc:25:21: note:   template argument deduction/substitution failed:
a.cc:49:35: note:   deduced conflicting types for parameter 'T' ('long int' and 'long long int')
   49 |     rev_fact_[MaxFact-1] = mod_pow(fact_[MaxFact-1], (T)MOD-2, MOD);
      |                            ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~