#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector,fast-math")
using namespace std;
namespace io {
const int L = (1 << 20) + 1;
char buf[L], *S, *T, c;
char getchar() {
  if (__builtin_expect(S == T, 0)) {
    T = (S = buf) + fread(buf, 1, L, stdin);
    return (S == T ? EOF : *S++);
  }
  return *S++;
}
int inp() {
  int x = 0, f = 1;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return x * f;
}
unsigned inpu() {
  unsigned x = 0;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    ;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return x;
}
long long inp_ll() {
  long long x = 0;
  int f = 1;
  char ch;
  for (ch = getchar(); !isdigit(ch); ch = getchar())
    if (ch == '-') f = -1;
  for (; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
    ;
  return x * f;
}
char B[25], *outs = B + 20, *outr = B + 20;
template <class T>
inline void print(register T a, register char x = 0) {
  if (x) *--outs = x, x = 0;
  if (!a)
    *--outs = '0';
  else
    while (a) *--outs = (a % 10) + 48, a /= 10;
  if (x) *--outs = x;
  fwrite(outs, outr - outs, 1, stdout);
  outs = outr;
}
};  // namespace io
using io ::inp;
using io ::inp_ll;
using io ::inpu;
using io ::print;
using i32 = int;
using i64 = long long;
using u8 = unsigned char;
using u32 = unsigned;
using u64 = unsigned long long;
using f64 = double;
using f80 = long double;
long long power(long long a, long long b, long long p) {
  if (!b) return 1;
  long long t = power(a, b / 2, p);
  t = t * t % p;
  if (b & 1) t = t * a % p;
  return t;
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
  if (b == 0) {
    x = 1;
    y = 0;
    return a;
  }
  long long px, py;
  long long d = exgcd(b, a % b, px, py);
  x = py;
  y = px - a / b * py;
  return d;
}
template <class T>
inline void freshmin(T &a, const T &b) {
  if (a > b) a = b;
}
template <class T>
inline void freshmax(T &a, const T &b) {
  if (a < b) a = b;
}
namespace ntt {
using word_t = u32;
using dword_t = u64;
template <word_t mod, word_t root>
class Mod {
 public:
  static constexpr int level = 17;
  static constexpr int all = (1 << level) - 1;
  word_t x;
  Mod() {}
  Mod(word_t n) : x(n) {}
  static word_t modulus() { return mod; }
  static Mod omega() { return Mod(root).pow((mod - 1) >> level); }
  Mod &operator+=(const Mod &rhs) {
    this->x += rhs.x;
    if (this->x >= mod) this->x -= mod;
    return *this;
  }
  Mod &operator-=(const Mod &rhs) {
    this->x += mod - rhs.x;
    if (this->x >= mod) this->x -= mod;
    return *this;
  }
  Mod &operator*=(const Mod &rhs) {
    this->x = dword_t(this->x) * rhs.x % mod;
    return *this;
  }
  Mod operator+(const Mod &rhs) const { return Mod(*this) += rhs; }
  Mod operator-(const Mod &rhs) const { return Mod(*this) -= rhs; }
  Mod operator*(const Mod &rhs) const { return Mod(*this) *= rhs; }
  word_t get() const { return this->x; }
  void set(word_t n) const { this->x = n; }
  Mod pow(word_t exp) const {
    Mod ret = Mod(1);
    for (Mod base = *this; exp; exp >>= 1, base *= base)
      if (exp & 1) ret *= base;
    return ret;
  }
  Mod inverse() const { return pow(mod - 2); }
  friend ostream &operator<<(ostream &os, const Mod &m) {
    return os << m.get();
  }
};
template <typename mod_t>
void convolve(mod_t *A, int s1, mod_t *B, int s2, bool cyclic = false) {
  int s = (cyclic ? max(s1, s2) : s1 + s2 - 1);
  int size = 1;
  while (size < s) size <<= 1;
  static int flag = 0;
  static mod_t roots[1 << mod_t::level];
  if (!flag) {
    flag = 1;
    roots[0] = 1;
    roots[1] = mod_t::omega();
    for (int i = 2; i < 1 << mod_t::level; ++i)
      roots[i] = roots[i - 1] * roots[1];
  }
  fill(A + s1, A + size, 0);
  ntt_dit4(A, size, 1, roots);
  if (A == B && s1 == s2) {
    for (int i = 0; i < size; ++i) A[i] *= A[i];
  } else {
    fill(B + s2, B + size, 0);
    ntt_dit4(B, size, 1, roots);
    for (int i = 0; i < size; ++i) A[i] *= B[i];
  }
  ntt_dit4(A, size, -1, roots);
  mod_t inv = mod_t(size).inverse();
  for (int i = 0; i < (cyclic ? size : s); ++i) A[i] *= inv;
}
template <typename mod_t>
void rev_permute(mod_t *A, int n) {
  int r = 0, nh = n >> 1;
  for (int i = 1; i < n; ++i) {
    for (int h = nh; !((r ^= h) & h); h >>= 1)
      ;
    if (r > i) swap(A[i], A[r]);
  }
}
template <typename mod_t>
void ntt_dit4(mod_t *A, int n, int sign, mod_t *roots) {
  rev_permute(A, n);
  int logn = __builtin_ctz(n);
  assert(logn <= mod_t::level);
  if (logn & 1)
    for (int i = 0; i < n; i += 2) {
      mod_t a = A[i], b = A[i + 1];
      A[i] = a + b;
      A[i + 1] = a - b;
    }
  mod_t imag = roots[1 << (mod_t::level - 2)];
  if (sign < 0) imag = imag.inverse();
  for (int e = 2 + (logn & 1); e <= logn; e += 2) {
    const int m = 1 << e;
    const int m4 = m >> 2;
    int dw = 1 << (mod_t::level - e);
    if (sign < 0) dw = mod_t::all + 1 - dw;
    const int block_size = min(n, max(m, (1 << 15) / int(sizeof(A[0]))));
    for (int k = 0; k < n; k += block_size) {
      int w = 0, w2 = 0, w3 = 0;
      for (int j = 0; j < m4; ++j) {
        for (int i = k + j; i < k + block_size; i += m) {
          mod_t a0 = A[i + m4 * 0], a2 = A[i + m4 * 1] * roots[w2];
          mod_t a1 = A[i + m4 * 2] * roots[w], a3 = A[i + m4 * 3] * roots[w3];
          mod_t t02 = a0 + a2, t13 = a1 + a3;
          A[i + m4 * 0] = t02 + t13;
          A[i + m4 * 2] = t02 - t13;
          t02 = a0 - a2, t13 = (a1 - a3) * imag;
          A[i + m4 * 1] = t02 + t13;
          A[i + m4 * 3] = t02 - t13;
        }
        w = (w + dw) & mod_t::all;
        w2 = (w + w) & mod_t::all;
        w3 = (w2 + w) & mod_t::all;
      }
    }
  }
}
}  // namespace ntt
const int MAXN = 1 << 17;
const int MOD = 998244353;
const int G = 3;
const f80 MI = f80(1) / MOD;
const int INF = 100001;
ntt::Mod<MOD, G> fact[MAXN], rfact[MAXN];
void init(int n) {
  fact[0] = 1;
  for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
  rfact[n] = fact[n].inverse();
  for (int i = n - 1; i >= 0; --i) rfact[i] = rfact[i + 1] * (i + 1);
}
void stirling(ntt::Mod<MOD, G> *s, int n) {
  if (n == 1) {
    s[0] = 0;
    s[1] = 1;
    return;
  }
  int m = n >> 1;
  stirling(s, m);
  static ntt::Mod<MOD, G> a[MAXN], b[MAXN];
  ntt::Mod<MOD, G> tmp = 1;
  for (int i = 0; i <= m; ++i, tmp *= m) {
    a[m - i] = s[i] * fact[i];
    b[i] = rfact[i] * tmp;
  }
  ntt::convolve(a, m + 1, b, m + 1);
  for (int i = 0; i <= m; ++i) b[i] = a[m - i] * rfact[i];
  ntt::convolve(s, m + 1, b, m + 1);
  if (n & 1) {
    s[n] = 0;
    for (int i = n; i >= 1; --i) s[i] = s[i] * (n - 1) + s[i - 1];
  }
}
ntt::Mod<MOD, G> stirling_first_type(int n, int k) {
  if (n == 0) return k == 0;
  if (n <= 1) return k;
  static ntt::Mod<MOD, G> s[MAXN];
  stirling(s, n);
  return s[k];
}
ntt::Mod<MOD, G> binomial(int n, int m) {
  return fact[n] * rfact[m] * rfact[n - m];
}
int main() {
  int N, A, B;
  cin >> N >> A >> B;
  if (A < 1 || B < 1 || A + B > N + 1) {
    puts("0");
    return 0;
  }
  init(N - 1);
  ntt::Mod<MOD, G> ans =
      ntt::Mod<MOD, G>(stirling_first_type(N - 1, A + B - 2)) *
      ntt::Mod<MOD, G>(binomial(A + B - 2, A - 1));
  cout << ans << endl;
  return 0;
}
