#include<bits/stdc++.h>
#include<atcoder/all>
#define chmin(x,y) (x) = min((x),(y))
#define chmax(x,y) (x) = max((x),(y))
using namespace std;
using namespace atcoder;
using ll = long long;
const ll mod = 998244353;
using mint = modint998244353;
using Graph = vector<vector<int>>;

const vector<int> dx = {1,0,-1,0}, dy = {0,1,0,-1};

int main(){
  // input
  int N,M,K;
  cin >> N >> M >> K;
  
  // prep: list up all adequate adjacent pair of indices
  vector<int> inv(M+1);
  for(int i = 1; i <= M; i++)
    inv[i] = M / i;
    
  vector<int> can_l(M+1,-1),can_r(M+1,1);
  for(int i = 1; i <= M; i++)
    for(int j = 1; j <= M; j++)
      if(abs(inv[i]-inv[j]) <= K){
        can_r[i] = j;
        if(can_l[i] == -1)
          can_r[i] = j;
      }
      
  // Check bounds on can_l and can_r to ensure they're within [1, M]
  for(int i = 1; i <= M; i++) {
    can_l[i] = max(1, can_l[i]); // Ensure can_l[i] is at least 1
    can_r[i] = min(M, can_r[i]); // Ensure can_r[i] does not exceed M
  }
  
  // prep: doubling + ruisekiwa
  vector<vector<mint>> dbl(31,vector<mint>(M+1,0));
  vector<vector<vector<mint>>>  rui(31,vector<vector<mint>>(M+1,vector<mint>(M+1,0)));
  for(int i = 1; i <= M; i++)
    dbl[0][i] = 1;
  for(int i = 1; i <= M; i++)
    for(int j = 1; j <= M; j++)
      rui[0][i][j] = rui[0][i-1][j] + rui[0][i][j-1] - rui[0][i-1][j-1] + dbl[0][i];
  
  
  for(int i = 0; i < 30; i++){
    for(int j = 1; j <= M; j++){
      vector<mint> tmp(M+1);
      for(int k = 1; k <= M; k++){
        mint add = (rui[i][can_r[k]][j] - rui[i][can_l[k]-1][j] - rui[i][can_r[k]][j-1] + rui[i][can_l[k]-1][j-1]);
        dbl[i+1][j] += dbl[i][k] * add;
        tmp[k] = add;
      }
      for(int k = 1; k <= M; k++)
        rui[i+1][j][k] = rui[i][j-1][k] + rui[i][j][k-1] - rui[i][j-1][k-1] + tmp[k];
    }
  }
  
  // solve: DP accelerated by doubling
  vector<vector<mint>> dp(31,vector<mint>(M+1,0));
  for(int j = 1; j <= M; j++)
    dp[0][j] = 1;
    
  --N;
  
  for(int i = 0; i < 30; i++){
    for(int j = 1; j <= M; j++){
      if(N & (1 << i)){
        for(int k = 1; k <= M; k++){
          mint add = (rui[i][can_r[k]][j] - rui[i][can_l[k]-1][j] - rui[i][can_r[k]][j-1] + rui[i][can_l[k]-1][j-1]);
          dp[i+1][j] += dp[i][k] * add;
        }
      }
      else dp[i+1][j] = dp[i][j];
    }
  }
  
  // output
  mint ans = 0;
  for(int j = 1; j <= M; j++)
    ans += dp[30][j];
  cout << ans.val() << endl;
}