import static java.lang.Math.*;
import java.io.*;
import java.util.*;

public class TopScore {
    final static long mod = 998244353l;
    final static int maxn = 5500;
    final static long infty = 1_000_000_009l;

    // final static boolean DEBUG = true;
    final static boolean DEBUG = false;

    // solve has the solution code

    static class Solver {

        long[][] C;

        public void solve() {
            C = new long[maxn][maxn];

            for (int n = 0; n < maxn; n++) {
                for (int r = 0; r < maxn; r++) {
                    if (r == 0) {
                        C[n][r] = 1l;
                        continue;
                    }
                    if (n == 0) {
                        C[n][r] = 0l;
                        continue;
                    }
                    C[n][r] = (C[n - 1][r - 1] + C[n - 1][r]) % mod;
                }
            }

            int p = in.gi(), s = in.gi(), r = in.gi();

            long ans = 0l;

            for (int h = r; h <= s; h++) {
                for (int q = 1; q <= p; q++) {
                    int S = s - q * h;
                    int P = p - q;
                    long cnt = 0l;
                    if (P > 0) {
                        for (int k = 0; k <= P; k++) {
                            int z = S - h * k + P - 1;
                            if (z < 0) continue;
                            long cur = (C[P][k] * C[z][P - 1]) % mod;
                            if (k % 2 == 0) {
                                cnt = (cnt + cur) % mod;
                            } else {
                                cnt = (cnt - cur + mod) % mod;
                            }
                        }
                    } else {
                        cnt = (S != 0) ? 0l : 1l;
                    }

                    debug("h = ", h, " q = ", q, " | " , S, " : ", P, " < ", h, " = ", cnt);

                    cnt = (cnt * C[p - 1][q - 1]) % mod;
                    cnt = (cnt * modexp(q, mod - 2)) % mod;

                    ans = (ans + cnt) % mod;    
                }
            }

            long total = C[s - r + p - 1][p - 1];
            debug("total = ", total);
            ans = (ans * modexp(total, mod - 2)) % mod;

            println(ans);
        }


        long modexp(long x, long ex) {
            long ans = 1l;
            while (ex > 0) {
                if ((ex & 1l) > 0) 
                    ans = (ans * x) % mod;
                ex >>= 1l;
                x = (x * x) % mod;
            }
            return ans;
        }

        PrintWriter out;
        FastInput in;
        Random random_source;

        void initRandom(Long x) {
            random_source = new Random(x);
        }

        void initRandom() {
            random_source = new Random(System.currentTimeMillis());
        }

        int randInt(int bound) { // [0..bound)
            return random_source.nextInt(bound);
        }

        int gcd(int x, int y) {
            while (y > 0) {
                int t = x % y;
                x = y; y = t;
            }
            return x;
        }

        void debug(Object... obj) {
            if (DEBUG) {
                out.print("# ");
                for (Object o : obj) {
                    out.print(o.toString());
                    out.print(" ");
                }
                out.println("");
                out.flush();
            }
        }

        void print(Object... obj) {
            for (Object o : obj) {
                out.print(o.toString());
            }
        }

        void println(Object... obj) {
            for (Object o : obj) {
                out.print(o.toString());
            }
            out.println("");
        } 

        void verify(boolean check) {    // equivalent to assert
            if (!check) {
                throw new RuntimeException("Verification error");
            }
        }

        Solver(PrintWriter out, FastInput in) {
            this.out = out; this.in = in;
        }
    }

    public static void main(String args[]) {
        FastInput in = new FastInput(System.in);
        PrintWriter out = new PrintWriter(System.out);
        Solver solver = new Solver(out, in);
        solver.solve();
        out.close();
    }
    
    static class FastInput {
        BufferedReader reader;
        StringTokenizer tok;

        public FastInput(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
            tok = null;
        }

        public String next() {
            while (tok == null || !tok.hasMoreTokens()) {
                try {
                    tok = new StringTokenizer(reader.readLine());
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return tok.nextToken();
        }

        public int gi() {
            return Integer.parseInt(next());
        }

        public long gl() {
            return Long.parseLong(next());
        }
    }

    static class Pair<A extends Comparable<A>, B extends Comparable<B>>
            implements Comparable<Pair<A, B>> {
        A F;
        B S;

        Pair(A x, B y) {
            F = x; S = y;
        }

        public boolean equals(Pair<A, B> oth) {
            return this.compareTo(oth) == 0;    
        }

        public int compareTo(Pair<A, B> Q) {
            if (this.F.compareTo(Q.F) == 0) {
                return this.S.compareTo(Q.S);
            } else {
                return this.F.compareTo(Q.F);
            }
        }

        public String toString() {
            return new StringBuilder("{")
                    .append(F.toString())
                    .append(", ")
                    .append(S.toString())
                    .append("}")
                    .toString();
        }
    }

    public static <A extends Comparable<A>, B extends Comparable<B>> Pair<A, B> make_pair(A a, B b) {
        return new Pair<A, B>(a, b);
    }

    static class IntPair extends Pair<Integer, Integer> {
        IntPair(Integer x, Integer y) {
            super(x, y);
        }
    }

    static class LongPair extends Pair<Long, Long> {
        LongPair(Long x, Long y) {
            super(x, y);
        }
    }
}
