#pragma GCC optimize("O3")
#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef long double ld;
#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

using uint = unsigned int;
using ull = unsigned long long;
template <uint MD> struct ModInt {
    using M = ModInt;
    // static int MD;
    uint v;
    ModInt(ll _v = 0) { set_v(uint(_v % MD + MD)); }
    M& set_v(uint _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    explicit operator bool() const { return v != 0; }
    M operator-() const { return M() - *this; }
    M operator+(const M& r) const { return M().set_v(v + r.v); }
    M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    M operator*(const M& r) const { return M().set_v(uint((ull)v * r.v % MD)); }
    M operator/(const M& r) const { return *this * r.inv(); }
    M& operator+=(const M& r) { return *this = *this + r; }
    M& operator-=(const M& r) { return *this = *this - r; }
    M& operator*=(const M& r) { return *this = *this * r; }
    M& operator/=(const M& r) { return *this = *this / r; }
    bool operator==(const M& r) const { return v == r.v; }
    bool operator!=(const M& r) const { return v != r.v; }
    M inv() const;
    friend istream& operator>>(istream& is, M& r) { ll x; is >> x; r = M(x); return is; }
    friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};

template<uint MD>
ModInt<MD> pow(ModInt<MD> x, ll n) {
    ModInt<MD> r = 1;
    while (n) {
        if (n & 1) r *= x;
        x *= x;
        n >>= 1;
    }
    return r;
}

template<uint MD>
ModInt<MD> ModInt<MD>::inv() const { return pow(*this, MD - 2); }
// or copy egcd and {return egcd(MD, v, 1).second;}

// if MD is from input
// this line is necessary, read later as you wish
// int ModInt::MD;

using Mint = ModInt<998244353>;
// using Mint = double;

const int M = 3e7 + 239;

Mint fact[M], inv[M];

Mint getC(int n, int k) {
    if (n < 0 || n < k || k < 0) {
        return 0;
    }
    return fact[n] * inv[n - k] * inv[k];
}

void solve() {
    int n, d, r;
    cin >> n >> d >> r;
    Mint ans = getC(n + d - 1, n - 1) * r;
    /*
    for (int y = 1; y <= d; y++) {
        for (int k = 1; k <= r; k++) {
            for (int l = k; l * y <= d && l <= n; l++) {
                Mint cur = getC(l - 1, k - 1) * getC(n, l) * getC(n + d - l * y - 1, d - l * y);
                if ((l - k) % 2 == 1) {
                    cur = -cur;
                }
                ans += cur;
            }
        }
    }
    ans /= getC(n + d - 1, n - 1);
    cout << ans << "\n";
    return;
    */
    for (int l = 1; l <= min(d, n); l++) {
        for (int y = 1; l * y <= d; y++) {
            Mint cur = getC(n - 1 + (d - l * y), d - l * y) * getC(n, l);
            if (l % 2 == 0) {
                cur = -cur;
            }
            /*Mint add = 0;
            for (int k = 1; k <= min(r, l); k++) {
                Mint sm = getC(l - 1, k - 1);
                if ((k - 1) % 2 == 1) {
                    sm = -sm;
                }
                add += sm;
            }
            cur *= add;*/
            if (l >= 2) {
                int bd = min(r, l) - 1;
                if (bd == l - 1) {
                    cur = 0;
                } else {
                    cur *= getC(l - 2, bd);
                    if (bd % 2 == 1) {
                        cur = -cur;
                    }
                }
            }
            ans += cur;
        }
    }
    //cerr << ans << "\n";
    ans /= getC(n + d - 1, n - 1);
    cout << ans << "\n";
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);

    fact[0] = 1;
    for (int i = 1; i < M; i++) {
        fact[i] = fact[i - 1] * i;
    }
    inv[M - 1] = fact[M - 1].inv();
    for (int i = M - 2; i >= 0; i--) {
        inv[i] = inv[i + 1] * (i + 1);
    }

    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }

    cerr << TIME << "\n";

    return 0;
}