#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("unroll-loops")
using namespace std;
const int mod = 998244353;
int power(int a, int b, int mod, int ans = 1) {
  for (; b; b >>= 1, a = 1LL * a * a % mod)
    if (b & 1) ans = 1LL * ans * a % mod;
  return ans;
}
namespace fft {
const int root = 31;
const int root_1 = power(root, mod - 2, mod);
int mPow(int a, int first) { return power(a, first, mod); }
void fft(vector<int>& a, bool invert) {
  int n = a.size();
  int PW = mPow(invert ? root_1 : root, (mod - 1) / n);
  for (int m = n, h; h = m / 2, m >= 2; PW = 1LL * PW * PW % mod, m = h) {
    for (int i = 0, w = 1; i < h; ++i, w = 1LL * w * PW % mod)
      for (int j = i; j < n; j += m) {
        int k = j + h, first = (a[j] - a[k] + mod) % mod;
        a[j] += a[k];
        a[j] %= mod;
        a[k] = 1LL * w * first % mod;
      }
  }
  for (int i = 0, j = 1; j < n - 1; ++j) {
    for (int k = n / 2; k > (i ^= k); k /= 2)
      ;
    if (j < i) swap(a[i], a[j]);
  }
  if (invert) {
    int rev = mPow(n, mod - 2);
    for (int i = 0; i < n; ++i) a[i] = 1LL * a[i] * rev % mod;
  }
}
vector<int> multiply(const vector<int>& a, const vector<int>& b) {
  int n = max(a.size(), b.size());
  vector<int> na = a, nb = b;
  na.resize(2 * n);
  nb.resize(2 * n);
  fft(na, false);
  fft(nb, false);
  for (int i = 0; i < 2 * n; ++i) na[i] = 1LL * na[i] * nb[i] % mod;
  fft(na, true);
  return na;
}
vector<int> findInverse(const vector<int>& f) {
  int n = f.size();
  vector<int> r(1, mPow(f[0], mod - 2));
  for (int it = 2; it <= n; it <<= 1) {
    vector<int> nr =
        multiply(multiply(r, r), vector<int>(f.begin(), f.begin() + it));
    nr.resize(it);
    for (int i = 0; i < nr.size(); ++i) nr[i] = mod - nr[i];
    for (int i = 0; i < it / 2; ++i) nr[i] = (2LL * r[i] + nr[i]) % mod;
    r = nr;
  }
  return r;
}
bool checkInverse(const vector<int>& a, const vector<int>& b) {
  for (int i = 0; i < a.size(); i++) {
    int val = 0;
    for (int j = 0; j <= i; j++) {
      val = (val + 1LL * a[i - j] * b[j]) % mod;
    }
    if (val != (i == 0)) return false;
  }
  return true;
}
vector<int> squareRoot(const vector<int>& f) {
  int n = f.size();
  vector<int> r(1, 1);
  int inv2 = mPow(2, mod - 2);
  for (int it = 2; it <= n; it <<= 1) {
    r.resize(it);
    vector<int> res =
        multiply(findInverse(r), vector<int>(f.begin(), f.begin() + it));
    res.resize(it);
    for (int i = 0; i < r.size(); ++i) {
      res[i] += r[i];
      if (res[i] >= mod) res[i] -= mod;
    }
    for (int i = 0; i < res.size(); ++i) res[i] = 1LL * res[i] * inv2 % mod;
    r = res;
  }
  return r;
}
};  // namespace fft
const int NN = 100100;
long long fac[NN], rev[NN];
long long C(int n, int k) {
  long long ans = fac[n] * rev[k] % mod * rev[n - k] % mod;
  return ans;
}
vector<int> calc(int l, int r) {
  if (l + 1 == r) {
    vector<int> ans;
    ans.resize(4);
    ans[0] = l;
    ans[1] = 1;
    return ans;
  }
  return fft::multiply(calc(l, (l + r >> 1)), calc((l + r >> 1), r));
}
int main() {
  fac[0] = 1;
  for (int i = 1; i < NN; i++) fac[i] = fac[i - 1] * i % mod;
  rev[NN - 1] = power(fac[NN - 1], mod - 2, mod);
  for (int i = NN - 2; i >= 0; i--) rev[i] = rev[i + 1] * (i + 1) % mod;
  int n, A, B;
  cin >> n >> A >> B;
  if (A + B - 1 > n) {
    puts("0");
    return 0;
  }
  if (n == 1) {
    if (A == B and A == 1)
      puts("1");
    else
      puts("0");
    return 0;
  }
  vector<int> ans = calc(0, n - 1);
  long long ANS = 1LL * ans[A + B - 2] * C(A + B - 2, A - 1) % mod;
  ANS = (ANS % mod + mod) % mod;
  cout << ANS << endl;
  return 0;
}
