#include <bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

#if __APPLE__
#define D for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl
template <class ...Ts> auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }
#else
#define D while (false)
#define LOG(...)
#endif

const int max_n = 15000474;


const int mod = 998244353;

inline void inc(int &x, int y) {
    x += y;
    if (x >= mod) {
        x -= mod;
    }
}

inline void dec(int &x, int y) {
    x -= y;
    if (x < 0) {
        x += mod;
    }
}

inline int mul(int x) {
    return x;
}

template<typename... Args>
inline int mul(int x, Args... args) {
    return (1LL * x * mul(args...)) % mod;
}

int power(int a, int b) {
    int res = 1 % mod;
    while (b) {
        if (b % 2) {
            res = mul(res, a);
        }
        b /= 2;
        a = mul(a, a);
    }
    return res;
}

int inv(int x) {
    return power(x, mod - 2);
}

string str_fraction(int x, int n = 20) {
    stringstream res;
    pair<int, int> best(x, 1);
    for (int j = 1; j < n; ++j) {
        best = min(best, {mul(x, j), j});
        best = min(best, {mod - mul(x, j), -j});
    }
    if (best.second < 0) {
        best.first *= -1;
        best.second *= -1;
    }
    res << best.first << "/" << best.second;
    return res.str();
}

template<int max_f, int max_rf>
struct BCCalculator {
    static_assert(max_f >= max_rf && max_rf >= 1);
    int f[max_f], rf[max_rf];

    BCCalculator() {
        f[0] = rf[0] = 1;
        for (int i = 1; i < max_f; ++i) {
            f[i] = mul(i, f[i - 1]);
        }
        rf[max_rf - 1] = inv(f[max_rf - 1]);
        for (int i = max_rf - 2; i > 0; --i) {
            rf[i] = mul(i + 1, rf[i + 1]);
        }
    }

    int get_c(int n, int k) const {
        if (n < k || k < 0) {
            return 0;
        }
        assert(n < max_f && k < max_rf && n - k < max_rf);
        return mul(f[n], mul(rf[k], rf[n - k]));
    }
};

BCCalculator<2 * max_n, max_n> bc;
int inversed[max_n];

int get_ways(int ones,int poses)
{
    if (ones<0){
        return 0;
    }
    return bc.get_c(ones+poses-1,poses-1);
}

int magic[max_n];
int magic2[max_n];
bool not_is_prime[max_n];

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);

    int n,d,r;
    cin>>n>>d>>r;
//    n=d=r=15000000;

    for (int i=0;i<max_n;i++){
        magic[i] = mul(bc.f[i+(n-1)], bc.rf[i]);
    }
    for (int i = 1; i < max_n; ++i) {
        inversed[i] = mul(bc.f[i - 1], bc.rf[i]);
    }

    for (int i = 2; i * i < max_n; ++i) {
        if (!not_is_prime[i]) {
            for (int j = i * i; j < max_n; j += i) {
                not_is_prime[j] = 1;
            }
        }
    }
    for (int i = 1; i <= d; ++i) {
        magic2[i] = magic[d - i];
    }
    for (int i = 2; i <= d; ++i) {
        if (!not_is_prime[i]) {
            for (int j = d / i; j >= 0; --j) {
                inc(magic2[j], magic2[j * i]);
            }
        }
    }

    int ans=0;
    int sign = 1;
    for (int k=1;k<=n;k++){
        sign = mod - sign;
        int sum1=0;
        int sum2=0;
        const int R1=min(k,r);
        if (k==1) {
            sum1= mod - 1;
        } else if (k==R1) {
            sum1=0;
        } else {
            sum1=mul(bc.rf[R1-1], inversed[k-1], bc.rf[k-R1-1]);
            if (R1 % 2) {
                sum1 = mod - sum1;
            }
        }
        const int L1=min(k,r)+1;
        if (L1>k){
            sum2=0;
        }
        else{
            sum2=mul(bc.rf[L1-1], inversed[k], bc.rf[k-L1]);
            if (L1 % 2) {
                sum2 = mod - sum2;
            }
        }
        sum2 = mul(sum2, r);
        int sum=sum1;
        inc(sum, sum2);
        sum = mul(sum, sign);
        sum = mul(sum, bc.rf[n - k]);
        inc(ans, mul(sum, magic2[k]));
    }
    ans=mul(ans, bc.rf[n-1], bc.f[n], inv(get_ways(d,n)));
    inc(ans, r);
    cout<<ans<<"\n";
}