/**
 * @author derrick20
 */

import java.io.*;
import java.util.*;

public class TopScorer {
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner();
        PrintWriter out = new PrintWriter(System.out);

        int P = sc.nextInt();
        int S = sc.nextInt();
        int R = sc.nextInt();
        // it should go up to s + p - 1, 5099, but let's be safe
        int MAX = (int) 1e5; // todo change this!
        fact = new long[MAX + 1];
        invFact = new long[MAX + 1];
        fact[0] = 1;
        invFact[0] = 1;
        for (int i = 1; i <= MAX; i++) {
            fact[i] = ((long) i * fact[i - 1]) % mod;
            invFact[i] = inv(fact[i]);
        }

        if (P == 1) {
            out.println(1);
        } else {
            // O(SP^2) = 5*10^7
            long wins = 0;
            long total = 0;
            for (int x = R; x <= S; x++) {
                // l = group that gets x
                // the remaining players P - 1 - l must get < x.
                for (int l = 0; P - 1 - l >= 0 && S - x - l * x >= 0; l++) {
                    int players = P - 1 - l;
                    int balls = S - x - l * x;
//                    System.out.println("Forced " + l + " other players to have exactly " + x + " balls");
//                    System.out.println("Remaining: players = " + players + " balls = " + balls);
                    long prob = (choose(P - 1, l) * f(players, balls, x)) % mod;
                    // prob of having this number of x's for players, then given
                    // that, the probability of winning is uniform among all x players
                    long contrib = (inv(l + 1) * prob) % mod;
                    wins = (wins + contrib) % mod;
//                    System.out.println("Prob: " + prob + " Contrib: " + contrib);
//                    System.out.println();
                }
                long ways = choose(S - x + P - 2, P - 2);
//                System.out.println("Ways for x = " + x + " = " + ways);
//                System.out.println("----------");
                total = (total + ways) % mod;
            }
            // we have now counted the number of winning states (scaling
            // with the f function). The probability is this divided by total
            // states.
            long prob = (wins * inv(total)) % mod;
            out.println(prob);
        }
        out.close();
    }

    // todo SET THE MOD
    static long mod = 998244353;
    static long[] fact, invFact;

    // f returns probability that with these parameters, we get an assignment
    // where all have < x balls.
    static long f(int players, int balls, int x) {
        // if there are no players, there MUST BE only 1 way.
        if (players == 0) {
//            ASSERT(balls <= x, "Gave impossible amt");
            /**
             * Key issue: add in logic for simple cases. If 0 players. it makes
             * no sense to give a positive number of balls, so 0 ways. If zero,
             * there is 1 way, i.e. do nothing.
             */
            return (balls == 0) ? 1 : 0;
        }
        long total = choose(balls + players - 1, players - 1);
        long complement = 0;
        int sign = 1;
        for (int k = 1; k <= players && balls - k * x >= 0; k++) {
            long amt = (choose(players, k) * choose(balls - k * x + players - 1, players - 1)) % mod;
            complement = (complement + sign * amt) % mod;
            sign *= -1;
        }
//        System.out.println("Ways for (players, balls) = " + players + " " + balls + ": Total " + total + ", Complement: " + complement);
        long ans = (total - complement + mod) % mod;
//        ans = (ans * inv(total)) % mod; // probability
        return ans;
    }

    static long choose(int n, int k) {
        ASSERT(k <= n, "Invalid choose");
        long ans = (fact[n] * invFact[n - k]) % mod;
        return (ans * invFact[k]) % mod;
    }

    static long inv(long x) {
        return fastExpo(x, mod - 2);
    }

    static long fastExpo(long x, long k) {
        long ans = 1;
        long bit = x;
        while (k > 0) {
            if (k % 2 == 1) {
                ans = (bit * ans) % mod;
            }
            bit = (bit * bit) % mod;
            k /= 2;
        }
        return ans;
    }

    static class FastScanner {
        private int BS = 1 << 16;
        private char NC = (char) 0;
        private byte[] buf = new byte[BS];
        private int bId = 0, size = 0;
        private char c = NC;
        private double cnt = 1;
        private BufferedInputStream in;

        public FastScanner() {
            in = new BufferedInputStream(System.in, BS);
        }

        public FastScanner(String s) {
            try {
                in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
            } catch (Exception e) {
                in = new BufferedInputStream(System.in, BS);
            }
        }

        private char getChar() {
            while (bId == size) {
                try {
                    size = in.read(buf);
                } catch (Exception e) {
                    return NC;
                }
                if (size == -1) return NC;
                bId = 0;
            }
            return (char) buf[bId++];
        }

        public int nextInt() {
            return (int) nextLong();
        }

        public int[] nextInts(int N) {
            int[] res = new int[N];
            for (int i = 0; i < N; i++) {
                res[i] = (int) nextLong();
            }
            return res;
        }

        public long[] nextLongs(int N) {
            long[] res = new long[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextLong();
            }
            return res;
        }

        public long nextLong() {
            cnt = 1;
            boolean neg = false;
            if (c == NC) c = getChar();
            for (; (c < '0' || c > '9'); c = getChar()) {
                if (c == '-') neg = true;
            }
            long res = 0;
            for (; c >= '0' && c <= '9'; c = getChar()) {
                res = (res << 3) + (res << 1) + c - '0';
                cnt *= 10;
            }
            return neg ? -res : res;
        }

        public double nextDouble() {
            double cur = nextLong();
            return c != '.' ? cur : cur + nextLong() / cnt;
        }

        public double[] nextDoubles(int N) {
            double[] res = new double[N];
            for (int i = 0; i < N; i++) {
                res[i] = nextDouble();
            }
            return res;
        }

        public String next() {
            StringBuilder res = new StringBuilder();
            while (c <= 32) c = getChar();
            while (c > 32) {
                res.append(c);
                c = getChar();
            }
            return res.toString();
        }

        public String nextLine() {
            StringBuilder res = new StringBuilder();
            while (c <= 32) c = getChar();
            while (c != '\n') {
                res.append(c);
                c = getChar();
            }
            return res.toString();
        }

        public boolean hasNext() {
            if (c > 32) return true;
            while (true) {
                c = getChar();
                if (c == NC) return false;
                else if (c > 32) return true;
            }
        }
    }

    static void ASSERT(boolean assertion, String message) {
        if (!assertion) throw new AssertionError(message);
    }
}