#include <bits/stdc++.h>
using namespace std;
const int maxn = 400100;
const int maxm = 500000 + 10;
const int maxt = 3000000 + 100;
const int maxk = 10 + 3;
const long long unit = 1LL;
const int INF = 0x3f3f3f3f;
const long long Inf = 0x3f3f3f3f3f3f3f3fLL;
const double eps = 1e-3;
const double inf = 1e15;
const long double pi = acos(-1.0);
const long long mod = 998244353, gg = 3, inv2 = 499122177;
inline long long read() {
  long long x = 0;
  bool t = false;
  char ch = getchar();
  while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
  if (ch == '-') t = true, ch = getchar();
  while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
  return t ? -x : x;
}
inline long long add(long long x, long long y) {
  return x + y >= mod ? x + y - mod : x + y;
}
inline long long sub(long long x, long long y) {
  return x < y ? x - y + mod : x - y;
}
inline long long mul(long long x, long long y) {
  return x * y - x * y / mod * mod;
}
inline long long upd(long long a) { return a += a >> 31 & mod; }
struct EasyMath {
  inline long long Quick_Pow(long long a, long long b) {
    long long sum = 1;
    for (; b; b >>= 1, a = (long long)a * a % mod)
      if (b & 1) sum = sum * a % mod;
    return sum;
  }
  inline long long inv(long long x) { return Quick_Pow(x, mod - 2); }
} em;
struct NTT {
  int n, k, rev[maxn];
  long long omega[22][maxn], iomega[22][maxn];
  void calc() {
    for (int k = 0; k < 20; ++k) {
      int n = (1 << k);
      const long long x = em.Quick_Pow(gg, (mod - 1) / n);
      omega[k][0] = iomega[k][0] = 1;
      for (int i = 1; i < n; i++)
        omega[k][i] = omega[k][i - 1] * x % mod,
        iomega[k][i] = em.inv(omega[k][i]);
    }
  }
  void init(int n) {
    this->n = n;
    k = (int)log2(n);
    for (int i = 0; i < n; i++)
      rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (k - 1));
  }
  void transform(long long *a, const long long *omega) {
    for (int i = 0; i < n; ++i)
      if (i < rev[i]) swap(a[i], a[rev[i]]);
    for (int len = 2; len <= n; len *= 2) {
      int mid = len >> 1;
      for (long long *p = a; p != a + n; p += len)
        for (int i = 0; i < mid; i++) {
          long long t = omega[n / len * i] * p[mid + i] % mod;
          p[mid + i] = sub(p[i], t);
          p[i] = add(p[i], t);
        }
    }
  }
  void dft(long long *a) { transform(a, omega[k]); }
  void idft(long long *a) {
    transform(a, iomega[k]);
    long long x = em.inv(n);
    for (int i = 0; i < n; i++) a[i] = a[i] * x % mod;
  }
} ntt;
struct Poly {
  void inverse(const long long *a, const int n, long long *b) {
    if (n == 1) {
      b[0] = em.inv(a[0]);
      return;
    }
    int p = n << 1;
    fill(b, b + p, 0);
    inverse(a, n >> 1, b);
    static long long x[maxn];
    copy(a, a + n, x), fill(x + n, x + p, 0);
    ntt.init(p), ntt.dft(x), ntt.dft(b);
    for (int i = 0; i < p; i++)
      b[i] = b[i] * ((2 - x[i] * b[i] % mod + mod) % mod) % mod;
    ntt.idft(b), fill(b + n, b + p, 0);
  }
  void Ginv(const long long *a, const long long n, long long *b) {
    int p = 1;
    while (p < n) p <<= 1;
    inverse(a, p, b);
    fill(b + n, b + p, 0);
  }
  void Multiply(const long long *a1, const int n1, const long long *a2,
                const int n2, long long *ans) {
    int n = 1;
    while (n < n1 + n2) n <<= 1;
    static long long c1[maxn], c2[maxn];
    copy(a1, a1 + n1, c1), fill(c1 + n1, c1 + n, 0);
    copy(a2, a2 + n2, c2), fill(c2 + n2, c2 + n, 0);
    ntt.init(n);
    ntt.dft(c1);
    ntt.dft(c2);
    for (int i = 0; i < n; i++) c1[i] = c1[i] * c2[i] % mod;
    ntt.idft(c1);
    for (int i = 0; i < n1 + n2 - 1; i++) ans[i] = c1[i];
  }
} poly;
long long n, a, b;
long long f[maxn], fac[maxn], ifac[maxn], inv[maxn];
void LEA(const long long *f, const int n, long long *g, int c) {
  if (n == 0) {
    g[0] = 1;
    return;
  }
  static long long a[maxn], b[maxn];
  for (register int i = (0); i <= (n); ++i) {
    a[i] = mul(f[n - i], fac[n - i]);
  }
  b[0] = 1;
  for (register int i = (1); i <= (n); ++i) {
    b[i] = ((((mul(b[i - 1], c)) * fac[i - 1]) % mod) * ifac[i]) % mod;
  }
  poly.Multiply(a, n + 1, b, n + 1, g);
  reverse(g, g + n + 1);
  for (register int i = (0); i <= (n); ++i) {
    g[i] = mul(g[i], ifac[i]);
  }
  fill(g + n + 1, g + 2 * n + 2, 0);
}
void Gao(int n, long long *f) {
  if (n == 0) {
    f[0] = 1;
    return;
  }
  int mid = (n >> 1), m = (mid << 1);
  Gao(mid, f);
  static long long g[maxn], tmp[maxn];
  LEA(f, mid, g, mid);
  poly.Multiply(f, mid + 1, g, mid + 1, tmp);
  if (n & 1) {
    f[0] = tmp[0] * m % mod;
    for (register int i = (1); i <= (m); ++i) {
      f[i] = add(mul(m, tmp[i]), tmp[i - 1]);
    }
    f[m + 1] = tmp[m];
  } else
    for (register int i = (0); i <= (m); ++i) {
      f[i] = tmp[i];
    }
}
long long xx[maxn], yy[maxn];
void GetInv(int n) {
  inv[1] = fac[0] = fac[1] = ifac[0] = ifac[1] = 1;
  for (register int i = (2); i <= (n); ++i) {
    inv[i] = ((mod - mod / i)) * inv[mod % i] % mod;
    fac[i] = fac[i - 1] * i % mod;
    ifac[i] = ifac[i - 1] * inv[i] % mod;
  }
}
long long C(long long n, long long m) {
  return fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
int main() {
  ntt.calc();
  n = read(), a = read(), b = read();
  GetInv(2 * n);
  Gao(n - 1, f);
  printf("%lld\n", (f[a + b - 2] * C(a + b - 2, a - 1)) % mod);
  return 0;
}
