#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
using vll = std::vector<ll>;
using pll = std::pair<ll, ll>;
template <typename T>
int sign(const T& t) {
  return (t > 0) - (t < 0);
}
template <typename T, typename U>
bool remax(T& a, U b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T, typename U>
bool remin(T& a, U b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
T gcd(T a, T b) {
  a = std::abs(a);
  b = std::abs(b);
  while (b) {
    a %= b;
    std::swap(a, b);
  }
  return a;
}
template <typename T>
T lcm(T a, T b) {
  a = std::abs(a);
  b = std::abs(b);
  return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
long long current_nanoseconds() {
  return std::chrono::steady_clock::now().time_since_epoch().count();
}
long long default_seed = current_nanoseconds();
uint32_t mrand_32t() {
  static std::mt19937 rng(default_seed);
  return rng();
}
uint64_t mrand_64t() {
  static std::mt19937_64 rng(default_seed);
  return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
  std::sort(std::begin(v), std::end(v));
  v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
namespace std {
template <typename A, typename B>
string to_string(const pair<A, B>& p) {
  string str;
  str += "(";
  str += to_string(p.first);
  str += ", ";
  str += to_string(p.second);
  str += ")";
  return str;
}
string to_string(bool value) { return value ? "true" : "false"; }
template <typename T>
string to_string(const vector<T>& vec) {
  string str = "{ ";
  bool first = true;
  for (const auto& it : vec) {
    if (!first) {
      str += ", ";
    }
    str += to_string(it);
    first = false;
  }
  str += " }";
  return str;
}
template <typename T>
string to_string(const set<T>& s) {
  string str = "{ ";
  bool first = true;
  for (const auto& it : s) {
    if (!first) {
      str += ", ";
    }
    str += to_string(it);
    first = false;
  }
  str += " }";
  return str;
}
template <typename K, typename V>
string to_string(const map<K, V>& m) {
  string str = "{ ";
  bool first = true;
  for (const auto& it : m) {
    if (!first) {
      str += ", ";
    }
    first = false;
    str += to_string(it.first);
    str += " -> ";
    str += to_string(it.second);
  }
  str += " }";
  return str;
}
string to_string(const string& s) { return "\"" + s + "\""; }
string to_string(const char* s) { return to_string(string(s)); }
string to_string(char ch) { return "\'" + string(1, ch) + "\'"; }
template <size_t N>
string to_string(const bitset<N>& b) {
  string res(N, '0');
  for (size_t i = 0; i < N; ++i) {
    res[i] = '0' + b[i];
  }
  return res;
}
template <typename T>
string to_string(const T& t) {
  std::stringstream ss;
  ss << t;
  return ss.str();
}
}  // namespace std
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  std::cerr << " " << std::to_string(H);
  debug_out(T...);
}
using namespace std;
const int MOD = 998244353;
void add(int& x, int y) { ((x += y) >= MOD) && (x -= MOD); }
void sub(int& x, int y) { add(x, -y + MOD); }
int mul(int x, int y) { return x * 1ll * y % MOD; }
int mpow(int a, int p) {
  int res = 1;
  for (; p > 0; p >>= 1, a = mul(a, a)) {
    if (p & 1) {
      res = mul(res, a);
    }
  }
  return res;
}
int inv(int x) {
  int y = mpow(x, MOD - 2);
  assert(mul(x, y) == 1);
  return y;
}
int p, s, r;
bool read() {
  if (!(cin >> p >> s >> r)) {
    return 0;
  }
  return 1;
}
const int MAXS = 5e3 + 500;
int binom[MAXS][MAXS * 2];
void precalc() {
  memset(binom, 0, sizeof binom);
  binom[0][0] = 1;
  for (int i = 1; i < MAXS; ++i) {
    binom[i][0] = 1;
    for (int j = 1; j < MAXS; ++j) {
      binom[i][j] = binom[i - 1][j];
      add(binom[i][j], binom[i - 1][j - 1]);
    }
  }
}
int binom_repeat(int n, int k) { return binom[n + k - 1][k]; }
int part(int cnt, int sum) {
  if (cnt == 0) {
    return (sum == 0);
  }
  assert(cnt > 0);
  return binom_repeat(sum + 1, cnt - 1);
}
int part(int cnt, int sum, int mx) {
  int ans = part(cnt, sum);
  for (int cnt_bad = cnt; cnt_bad > 0; --cnt_bad) {
    const int rest_sum = sum - cnt_bad * mx;
    if (rest_sum < 0) {
      continue;
    }
    int cur = binom[cnt][cnt_bad];
    cur = mul(cur, part(cnt, rest_sum));
    if (cnt_bad % 2 == 1) {
      sub(ans, cur);
    } else {
      add(ans, cur);
    }
  }
  return ans;
}
int solve() {
  if (p == 1) {
    return 1;
  }
  vi ans_with(p + 1, 0);
  int all = 0;
  ;
  for (int mx = r; mx <= s; ++mx) {
    const int cur_all = part(p - 1, s - mx);
    add(all, cur_all);
    ;
    for (int cnt = 0; cnt <= p - 1 && (cnt + 1) * mx <= s; ++cnt) {
      int cur = binom[p - 1][cnt];
      cur = mul(cur, part(p - 1 - cnt, s - (cnt + 1) * mx, mx));
      add(ans_with[cnt], cur);
    }
  }
  int good = 0;
  for (int cnt = 0; cnt <= p - 1; ++cnt) {
    int cur = ans_with[cnt];
    ;
    cur = mul(cur, inv(cnt + 1));
    add(good, cur);
  };
  int ans = good;
  ans = mul(ans, inv(all));
  ;
  return ans;
}
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout.tie(nullptr);
  cout.precision(12);
  cout << fixed;
  precalc();
  while (read()) {
    auto ans = solve();
    cout << ans << endl;
    break;
  }
  return 0;
}
