#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmin(T &a, T b) {
  a = min(a, b);
}
template <typename T>
void chkmax(T &a, T b) {
  a = max(a, b);
}
inline int fread(void) {
  int ret = 0, op = 1;
  char ch = getchar();
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') op = -1;
  for (; isdigit(ch); ch = getchar()) ret = (ret << 1) + (ret << 3) - '0' + ch;
  return ret * op;
}
const int MAXN = 5e6 + 10;
const int N = 2e5;
const int MAXM = +10;
const int mod = 998244353;
const int inv2 = ((mod + 1) >> 1);
const int gg = 3;
int fpow(int base, int top) {
  int ret = 1;
  for (; top; top >>= 1) {
    if (top & 1) ret = 1ll * ret * base % mod;
    base = 1ll * base * base % mod;
  }
  return ret;
}
namespace Math {
inline bool check(int x) { return fpow(x, (mod - 1) / 2) == 1; }
inline int random(void) { return 1ll * rand() * rand() % mod; }
int w;
struct Maths {
  int a, b;
  Maths(int _a = 0, int _b = 0) : a(_a), b(_b) {}
  Maths operator+(const Maths you) {
    return Maths((a + you.a) % mod, (b + you.b) % mod);
  }
  Maths operator*(const Maths you) {
    Maths ret;
    ret.a = 1ll * a * you.a % mod + 1ll * b * you.b % mod * w % mod;
    ret.a %= mod;
    ret.b = (1ll * a * you.b % mod + 1ll * b * you.a % mod) % mod;
    return ret;
  }
};
Maths Mpow(Maths base, int top) {
  Maths ret = base;
  top--;
  for (; top; top >>= 1) {
    if (top & 1) ret = ret * base;
    base = base * base;
  }
  return ret;
}
inline int Cipolla(int n) {
  if (!check(n)) return -1;
  int rnd, ret;
  while (1) {
    rnd = random();
    w = 1ll * rnd * rnd % mod;
    w = (w - n + mod) % mod;
    if (!check(w)) break;
  }
  ret = Mpow(Maths(rnd, 1), (mod + 1) / 2).a;
  return min(ret, mod - ret);
}
}  // namespace Math
int n, m, rev[MAXN], mxN, lg2[MAXN], inv[MAXN], Gn[MAXN];
inline void process(int need) {
  for (mxN = 1; mxN < need; mxN <<= 1)
    ;
  lg2[1] = 0;
  for (int i = 2; i <= mxN; ++i) lg2[i] = lg2[i >> 1] + 1;
  for (int i = 0; i < mxN; ++i) {
    rev[i] = rev[i >> 1] >> 1;
    if (i & 1) rev[i] |= (mxN >> 1);
  }
  inv[1] = 1;
  for (int i = 2; i <= mxN; ++i)
    inv[i] = 1ll * (mod - mod / i) * inv[mod % i] % mod;
  for (int len = 1; len < mxN; len <<= 1) {
    int sign = fpow(gg, (mod - 1) / (len << 1));
    Gn[len] = 1;
    for (int i = 1; i < len; ++i)
      Gn[len + i] = 1ll * Gn[len + i - 1] * sign % mod;
  }
}
unsigned long long tv[MAXN];
namespace Poly {
inline void NTT(vector<int> &F, int n, int tp) {
  if (tp == -1) reverse(F.begin() + 1, F.end());
  int tn = lg2[mxN / n];
  for (int i = 0; i < n; ++i) tv[i] = F[i];
  for (int i = 0; i < n; ++i)
    if ((rev[i] >> tn) < i) swap(tv[i], tv[rev[i] >> tn]);
  for (int len = 2; len <= n; len <<= 1) {
    for (int i = 0; i < n; i += len) {
      for (int j = i; j < i + len / 2; ++j) {
        int now = 1ll * Gn[(len >> 1) + j - i] * tv[j + len / 2] % mod;
        tv[j + len / 2] = tv[j] - now + mod;
        tv[j] = tv[j] + now;
      }
    }
  }
  for (int i = 0; i < n; ++i) F[i] = tv[i] % mod;
  if (tp == 1) return;
  int invn = fpow(n, mod - 2);
  for (int i = 0; i < n; ++i) F[i] = 1ll * F[i] * invn % mod;
}
vector<int> fix(vector<int> a, int n) {
  a.resize(n);
  return a;
}
vector<int> operator*(vector<int> a, vector<int> b) {
  if (a.empty() || b.empty()) return vector<int>();
  int used = a.size() + b.size() - 1;
  int lim = (1 << (lg2[used - 1] + 1));
  a.resize(lim);
  b.resize(lim);
  NTT(a, lim, 1);
  NTT(b, lim, 1);
  for (int i = 0; i < lim; ++i) a[i] = 1ll * a[i] * b[i] % mod;
  NTT(a, lim, -1);
  return fix(a, used);
}
vector<int> operator+(vector<int> a, vector<int> b) {
  int lim = max(a.size(), b.size());
  a.resize(lim);
  for (int i = 0; i < lim; ++i) {
    a[i] = a[i] + b[i];
    if (a[i] >= mod) a[i] -= mod;
  }
  return a;
}
vector<int> operator-(vector<int> a, vector<int> b) {
  int lim = max(a.size(), b.size());
  a.resize(lim);
  for (int i = 0; i < lim; ++i) {
    a[i] = a[i] - b[i];
    if (a[i] < 0) a[i] += mod;
  }
  return a;
}
vector<int> operator*(vector<int> a, int x) {
  int lim = a.size();
  for (int i = 0; i < lim; ++i) a[i] = 1ll * a[i] * x % mod;
  return a;
}
vector<int> Inv(vector<int> a) {
  int n = a.size();
  if (n == 1) {
    return vector<int>(1, fpow(a[0], mod - 2));
  }
  vector<int> b = Inv(fix(a, (n + 1) >> 1));
  return fix(b * 2 - a * b * b, n);
}
vector<int> Sqrt(vector<int> a) {
  int n = a.size();
  if (n == 1) {
    return vector<int>(1, Math::Cipolla(a[0]));
  }
  vector<int> b = fix(Sqrt(fix(a, (n + 1) >> 1)), n);
  return fix(((b + a * Inv(b))) * inv2, n);
}
vector<int> Deriv(vector<int> a) {
  int n = a.size();
  for (int i = 0; i < n - 1; ++i) {
    a[i] = 1ll * a[i + 1] * (i + 1) % mod;
  }
  a.pop_back();
  return a;
}
vector<int> Intgal(vector<int> a) {
  int n = a.size();
  a.push_back(0);
  for (int i = n; i >= 1; --i) {
    a[i] = 1ll * a[i - 1] * inv[i] % mod;
  }
  a[0] = 0;
  return a;
}
vector<int> Ln(vector<int> a) {
  int lim = a.size();
  a = fix(Intgal(Deriv(a) * Inv(a)), lim);
  return a;
}
vector<int> Exp(vector<int> a) {
  int n = a.size();
  if (n == 1) return vector<int>(1, 1);
  vector<int> b = fix(Exp(fix(a, (n + 1) >> 1)), n);
  return fix(b - b * (Ln(b) - a), n);
}
vector<int> operator/(vector<int> a, vector<int> b) {
  int n = a.size(), m = b.size();
  reverse(a.begin(), a.end()), reverse(b.begin(), b.end());
  a.resize(n - m + 1), b.resize(n - m + 1);
  a = fix(a * Inv(b), n - m + 1);
  reverse(a.begin(), a.end());
  return a;
}
vector<int> operator%(vector<int> a, vector<int> b) {
  int n = a.size(), m = b.size();
  a = a - (a / b) * b;
  return fix(a, m - 1);
}
vector<int> Shift(vector<int> a) {
  int n = a.size();
  a.push_back(0);
  for (int i = n; i >= 1; --i) a[i] = a[i - 1];
  a[0] = 0;
  a.pop_back();
  return a;
}
};  // namespace Poly
using namespace Poly;
const int MAXB = 150 + 10;
namespace Composit {
vector<int> A1[MAXB], A2[MAXB];
vector<int> compInv(vector<int> f) {
  int n = f.size();
  int siz = sqrt(n) + 1;
  int lim = 1;
  for (; lim < n; lim <<= 1)
    ;
  for (int i = 0; i < n - 1; ++i) f[i] = f[i + 1];
  f.pop_back();
  f = fix(Inv(f), lim);
  A1[0] = vector<int>(1, 1);
  A1[0].resize(lim);
  for (int i = 1; i <= siz; ++i) A1[i] = fix(A1[i - 1] * f, lim);
  A2[0] = vector<int>(1, 1);
  A2[0].resize(lim);
  for (int i = 1; i <= siz; ++i) A2[i] = fix(A2[i - 1] * A1[siz], lim);
  vector<int> ret;
  ret.resize(lim);
  for (int i = 0; i < siz; ++i) {
    for (int j = 0; j < siz && i * siz + j < n; ++j) {
      int tmp = 0;
      for (int k = 0; k <= i * siz + j - 1; ++k) {
        tmp += 1ll * A2[i][k] * A1[j][i * siz + j - 1 - k] % mod;
        tmp %= mod;
      }
      ret[i * siz + j] = 1ll * tmp * fpow(i * siz + j, mod - 2) % mod;
    }
  }
  return fix(ret, n);
}
}  // namespace Composit
inline void init(void) {}
vector<int> F, G, H, Ans;
int fac[MAXN], ifac[MAXN];
void StirlingOne(int len) {
  if (!len) {
    Ans = vector<int>(1, 1);
    return;
  }
  if (len == 1) {
    Ans.resize(2);
    Ans[1] = 1;
    return;
  }
  StirlingOne(len >> 1);
  int nlen = len >> 1;
  F.resize(nlen + 1);
  G.resize(nlen + 1);
  for (int i = 0; i <= nlen; ++i) F[i] = 1ll * Ans[i] * fac[i] % mod;
  int tmp = 1;
  for (int i = 0; i <= nlen; ++i)
    G[i] = 1ll * tmp * ifac[i] % mod, tmp = 1ll * nlen * tmp % mod;
  reverse(F.begin(), F.end());
  H = fix(F * G, nlen + 1);
  for (int i = 0; i <= nlen; ++i) F[i] = 1ll * H[nlen - i] * ifac[i] % mod;
  Ans = fix(F * Ans, len + 1);
  if (len & 1) {
    for (int i = len; i >= 1; --i)
      Ans[i] = (Ans[i - 1] + 1ll * Ans[i] * (len - 1) % mod) % mod;
    Ans[0] = 1ll * Ans[0] * (len - 1) % mod;
    return;
  }
}
int A, B;
int binom(int n, int m) {
  return 1ll * fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
inline void work(void) {
  n = fread();
  process(N << 1);
  A = fread(), B = fread();
  fac[0] = 1;
  for (int i = 1; i <= N; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
  ifac[N] = fpow(fac[N], mod - 2);
  for (int i = N - 1; i >= 0; --i) ifac[i] = 1ll * ifac[i + 1] * (i + 1) % mod;
  int ling = 0;
  StirlingOne(n - 1);
  if (A + B - 2 > n - 1) {
    printf("0");
    return;
  }
  int ans = 1ll * Ans[A + B - 2] * binom(A + B - 2, A - 1) % mod;
  printf("%d", ans);
}
int main() {
  init();
  work();
  return 0;
}
