import std;

void main () {
    const long MOD = 998244353;
    int N, M, K; readln.read(N, M, K);

    // 行列累乗で解ける -> Kがデカすぎます...
    // 線形漸化式 -> 行列は可能。 行列 -> 線形漸化式は厳しいね。(これとか)
    // よく考えれば割って切り捨ての種類数は高々√Mじゃない？ -> これなら行列累乗出来ますね。

    long[][] prod (long[][] A, long[][] B) {
        const int d = A.length.to!int;
        auto res = new long[][](d, d);
        foreach (i; 0..d) {
            foreach (j; 0..d) {
                foreach (k; 0..d) {
                    res[i][j] += 1L * A[i][k] * B[k][j] % MOD;
                }
                res[i][j] %= MOD;
            }
        }

        return res;
    }

    int[int] count;
    foreach (i; 1..M + 1) count[M / i]++;

    auto res = new int[](0);
    foreach (k, v; count) {
        res ~= k;
    }
    res.sort;

    const int d = count.length.to!int;
    auto mat = new long[][](d, d);
    auto vec = new long[](d);

    foreach (i; 0..d) vec[i] = count[res[i]];

    foreach (i; 0..d) {
        foreach (j; 0..d) {
            if (abs(res[i] - res[j]) <= K) mat[i][j] = count[res[j]];
        }
    }

    // 行列累乗
    auto m = new long[][](d, d);
    foreach (i; 0..d) m[i][i] = 1;

    N--;
    foreach (i; 0..31) {
        if (0 < (N & (1L << i))) {
            m = prod(mat, m);
        }
        mat = prod(mat, mat);
    }

    // 解答
    long ans = 0;
    foreach (i; 0..d) {
        foreach (j; 0..d) {
            ans += 1L * vec[i] * m[i][j] % MOD;
        }
        ans %= MOD;
    }

    writeln(ans);
}

void read (T...) (string S, ref T args) {
    import std.conv : to;
    import std.array : split;
    auto buf = S.split;
    foreach (i, ref arg; args) {
        arg = buf[i].to!(typeof(arg));
    }
}