#include <bits/stdc++.h>
using namespace std;
constexpr int inf32 = 0x3f3f3f3f;
constexpr long long inf64 = 0x3f3f3f3f3f3f3f3f;
constexpr int mod = 998244353;
constexpr int G = 3;
struct mint {
  int first;
  mint(int first = 0) : first(first) {}
  friend mint operator+(const mint a, const mint &b) {
    int first = a.first + b.first;
    return mint(first >= mod ? first - mod : first);
  }
  friend mint operator-(const mint a, const mint &b) {
    int first = a.first - b.first;
    return mint(first < 0 ? first + mod : first);
  }
  friend mint operator*(const mint a, const mint &b) {
    return mint(1ll * a.first * b.first % mod);
  }
};
int mypow(int a, int first = mod - 2, int res = 1) {
  for (; first; first >>= 1, a = (mint(a) * a).first)
    if (first & 1) res = (mint(res) * a).first;
  return res;
}
vector<int> rev, w = {0, 1};
void dft(vector<int> &a) {
  const int n = (int)((a).size());
  if ((int)((rev).size()) != n) {
    rev.resize(n);
    for (int i = 0; i < (n); ++i) rev[i] = (rev[i / 2] / 2) | ((i & 1) * n / 2);
  }
  if ((int)((w).size()) < n) {
    int szw = (int)((w).size());
    for (w.resize(n); szw < n; szw *= 2) {
      const int wn = mypow(G, (mod - 1) / (szw * 2));
      for (int i = szw / 2; i < szw; ++i)
        w[2 * i] = w[i], w[2 * i + 1] = (mint(w[i]) * wn).first;
    }
  }
  for (int i = 0; i < (n); ++i)
    if (i < rev[i]) swap(a[i], a[rev[i]]);
  for (int mid = 1, first; mid < n; mid *= 2)
    for (int i = 0; i < n; i += mid * 2)
      for (int j = 0; j < (mid); ++j) {
        int u = a[i | j], v = 1ll * w[mid | j] * a[mid | i | j] % mod;
        a[i | j] = (mint(u) + v).first;
        a[mid | i | j] = (mint(u) - v).first;
      }
}
void idft(vector<int> &a) {
  const int n = (int)((a).size()), in = n == 1 ? 1 : mod - mod / n;
  reverse(a.begin() + 1, a.end()), dft(a);
  for (int i = 0; i < (n); ++i) a[i] = (mint(a[i]) * in).first;
}
struct poly {
  vector<int> a;
  poly() {}
  poly(int first) {
    if (first) a = {first};
  }
  poly(const vector<int> &a0) : a(a0) {
    while ((int)((a).size()) && !a.back()) a.pop_back();
  }
  int size() const { return (int)((a).size()); }
  int operator[](int i) const { return (i < 0 || i >= size()) ? 0 : a[i]; }
  poly mulxk(int k) const {
    vector<int> b = a;
    b.insert(b.begin(), k, 0);
    return poly(b);
  }
  poly divxk(int k) const {
    return size() <= k ? poly() : poly(vector<int>(a.begin() + k, a.end()));
  }
  poly modxk(int k) const {
    return poly(vector<int>(a.begin(), a.begin() + min(k, size())));
  }
  poly rev() const {
    vector<int> b = a;
    reverse((b).begin(), (b).end());
    return poly(b);
  }
  friend poly operator+(const poly a, const poly &b) {
    vector<int> res(max((int)((a).size()), (int)((b).size())));
    for (int i = 0; i < ((int)((res).size())); ++i)
      res[i] = (mint(a[i]) + b[i]).first;
    return poly(res);
  }
  friend poly operator-(const poly a, const poly &b) {
    vector<int> res(max((int)((a).size()), (int)((b).size())));
    for (int i = 0; i < ((int)((res).size())); ++i)
      res[i] = (mint(a[i]) - b[i]).first;
    return poly(res);
  }
  friend poly operator*(poly a, poly b) {
    int n = 1, mn = (int)((a).size()) + (int)((b).size()) - 1;
    while (n < mn) n *= 2;
    a.a.resize(n), b.a.resize(n), dft(a.a), dft(b.a);
    for (int i = 0; i < (n); ++i) a.a[i] = (mint(a[i]) * b[i]).first;
    return idft(a.a), poly(a.a);
  }
  poly &operator+=(poly b) { return (*this) = (*this) + b; }
  poly &operator-=(poly b) { return (*this) = (*this) - b; }
  poly &operator*=(poly b) { return (*this) = (*this) * b; }
  poly deriv() const {
    if (!(int)((a).size())) return poly();
    vector<int> res(size() - 1);
    for (int i = 0; i < (size() - 1); ++i)
      res[i] = (mint(i + 1) * a[i + 1]).first;
    return poly(res);
  }
  poly integr() const {
    if (!(int)((a).size())) return poly();
    vector<int> res(size() + 1);
    for (int i = 0; i < (size()); ++i)
      res[i + 1] = (mint(a[i]) * mypow(i + 1)).first;
    return poly(res);
  }
  poly inv(int m) const {
    poly first(mypow(a[0]));
    for (int k = 1; k < m;)
      k *= 2, first = (first * (2 - modxk(k) * first)).modxk(k);
    return first.modxk(m);
  }
  friend poly operator/(const poly a, const poly &b) {
    int n = (int)((a).size()), m = (int)((b).size());
    return (a.rev() * b.rev().inv(n - m + 1)).modxk(n - m + 1).rev();
  }
  poly &operator/=(poly b) { return (*this) = (*this) / b; }
  poly log(int m) const { return (deriv() * inv(m)).integr().modxk(m); }
  poly exp(int m) const {
    poly first(1);
    for (int k = 1; k < m;)
      k *= 2, first = (first * (1 - first.log(k) + modxk(k))).modxk(k);
    return first.modxk(m);
  }
  poly sqrt(int m) const {
    poly first(1);
    for (int k = 1; k < m;)
      k *= 2, first = (first + (modxk(k) * first.inv(k)).modxk(k)) *
                      ((mod + 1) / 2);
    return first.modxk(m);
  }
  poly pow(int k, int m) const { return (log(m) * k).exp(m); }
};
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int n, a, b;
  cin >> n >> a >> b;
  if (a + b - 1 > n) return !(cout << "0\n");
  vector<int> fac(n), inv(n + 1), ifac(n);
  fac[0] = ifac[0] = inv[1] = 1;
  for (int i = 0; i < (n); ++i)
    if (i >= 2) inv[i] = (mint(inv[mod % i]) * (mod - mod / i)).first;
  for (int i = 0; i < (n); ++i)
    if (i >= 1)
      fac[i] = (mint(fac[i - 1]) * i).first,
      ifac[i] = (mint(ifac[i - 1]) * inv[i]).first;
  auto stir1 = [&](int n, int k) {
    if (n < 0 || k < 0 || k > n) return 0;
    return (mint(((poly(inv).divxk(1)).pow(k, n + 1))[n - k]) * fac[n] *
            ifac[k])
        .first;
  };
  auto cho = [&](int n, int m) {
    if (m > n || n < 0 || m < 0) return 0;
    return (mint(fac[n]) * ifac[m] * ifac[n - m]).first;
  };
  cout << (mint(stir1(n - 1, a + b - 2)) * cho(a + b - 2, a - 1)).first << '\n';
  return 0;
}
