960_G. Bandit Blues_9740
Japate, while traveling through the forest of Mala, saw N bags of gold lying in a row. Each bag has some distinct weight of gold between 1 to N. Japate can carry only one bag of gold with him, so he uses the following strategy to choose a bag.

Initially, he starts with an empty bag (zero weight). He considers the bags in some order. If the current bag has a higher weight than the bag in his hand, he picks the current bag.

Japate put the bags in some order. Japate realizes that he will pick A bags, if he starts picking bags from the front, and will pick B bags, if he starts picking bags from the back. By picking we mean replacing the bag in his hand with the current one.

Now he wonders how many permutations of bags are possible, in which he picks A bags from the front and B bags from back using the above strategy.

Since the answer can be very large, output it modulo 998244353.

Input

The only line of input contains three space separated integers N (1 ≤ N ≤ 105), A and B (0 ≤ A, B ≤ N).

Output

Output a single integer — the number of valid permutations modulo 998244353.

Examples

Input

1 1 1


Output

1

Input

2 1 1


Output

0

Input

2 2 1


Output

1

Input

5 2 2


Output

22

Note

In sample case 1, the only possible permutation is [1]

In sample cases 2 and 3, only two permutations of size 2 are possible:{[1, 2], [2, 1]}. The values of a and b for first permutation is 2 and 1, and for the second permutation these values are 1 and 2. 

In sample case 4, out of 120 permutations of [1, 2, 3, 4, 5] possible, only 22 satisfy the given constraints of a and b.
#include <bits/stdc++.h>
using namespace std;
namespace NTT {
const int EXP = 23;
const unsigned long long EXP_MULT = 119, NTT_MOD = (EXP_MULT << EXP) + 1;
unsigned long long rt[EXP + 1], invrt[EXP + 1];
bool built;
unsigned long long modPow(unsigned long long a, unsigned long long p) {
  return p ? modPow((a) * (a) % NTT_MOD, p >> 1) * (p & 1 ? a : 1) % NTT_MOD
           : 1;
}
unsigned long long invMod(unsigned long long a) {
  return modPow(a, NTT_MOD - 2);
}
unsigned long long findCyclic() {
  vector<long long> multFactors;
  unsigned long long temp = EXP_MULT;
  for (long long i = 2; i * i <= temp; i += 2) {
    if (temp % i == 0) multFactors.push_back(i);
    while (temp % i == 0) temp /= i;
    if (i == 2) i--;
  }
  if (temp > 1) multFactors.push_back(temp);
  for (long long i = 2; i < NTT_MOD; i++) {
    bool works = 1;
    if (modPow(i, NTT_MOD >> 1) == 1) works = 0;
    for (const int factor : multFactors)
      if (modPow(i, NTT_MOD / factor) == 1) works = 0;
    if (works) return i;
  }
}
void buildRT() {
  if (built) return;
  built = 1;
  rt[EXP] = modPow(findCyclic(), EXP_MULT);
  for (int i = (EXP)-1; i >= 0; i--)
    rt[i] = (rt[i + 1]) * (rt[i + 1]) % NTT_MOD;
  for (int i = 0; i < (EXP + 1); i++) invrt[i] = invMod(rt[i]);
}
int rev(int idx, int sz) {
  int tmp = 1, res = 0;
  sz >>= 1;
  while (sz) {
    if (sz & idx) res |= tmp;
    sz >>= 1;
    tmp <<= 1;
  }
  return res;
}
vector<unsigned long long> bitReverseCopy(vector<unsigned long long> val) {
  vector<unsigned long long> res(val.size());
  for (int i = 0; i < (val.size()); i++) res[i] = val[rev(i, val.size())];
  return res;
}
vector<unsigned long long> ntt(vector<unsigned long long> val) {
  buildRT();
  vector<unsigned long long> res = bitReverseCopy(val);
  int n = res.size();
  for (int i = (1); i < (32 - __builtin_clz(n)); i++) {
    int m = 1 << i;
    unsigned long long wm = rt[i];
    for (int k = 0; k < n; k += m) {
      unsigned long long w = 1;
      for (int j = 0; j < (m >> 1); j++) {
        unsigned long long t = w * res[k + j + (m >> 1)] % NTT_MOD;
        unsigned long long u = res[k + j];
        res[k + j] = (u + t) % NTT_MOD;
        res[k + j + (m >> 1)] = (u + NTT_MOD - t) % NTT_MOD;
        w = (w * wm) % NTT_MOD;
      }
    }
  }
  return res;
}
vector<unsigned long long> invntt(vector<unsigned long long> val) {
  swap(rt, invrt);
  vector<unsigned long long> res = ntt(val);
  swap(rt, invrt);
  unsigned long long u = invMod(val.size());
  for (int i = 0; i < (res.size()); i++) res[i] = (res[i] * u) % NTT_MOD;
  return res;
}
vector<unsigned long long> conv(vector<unsigned long long> a,
                                vector<unsigned long long> b) {
  int finalSZ = a.size() + b.size() - 1;
  int neededSZ = 1 << (32 - __builtin_clz(finalSZ - 1));
  a.resize(neededSZ), b.resize(neededSZ);
  a = ntt(a), b = ntt(b);
  for (int i = 0; i < (neededSZ); i++) a[i] = a[i] * b[i] % NTT_MOD;
  a = invntt(a);
  a.resize(finalSZ);
  return a;
}
};  // namespace NTT
using namespace NTT;
struct Polynomial {
  int deg;
  unsigned long long* coefficients;
  Polynomial(int d = 0) {
    deg = d;
    coefficients = new unsigned long long[deg + 1];
    memset(coefficients, 0, (deg + 1) * sizeof(unsigned long long));
  }
  Polynomial operator()(Polynomial p) {
    Polynomial curr;
    curr[0] = 1;
    Polynomial res;
    for (int i = 0; i < (deg + 1); i++) {
      res += curr * coefficients[i];
      curr *= p;
    }
    return res;
  }
  Polynomial operator+(unsigned long long a) {
    Polynomial p(deg);
    for (int i = 0; i < (deg + 1); i++) p[i] = coefficients[i];
    p[0] += a;
    p[0] %= NTT_MOD;
    return p;
  }
  Polynomial operator-(unsigned long long a) {
    Polynomial p(deg);
    for (int i = 0; i < (deg + 1); i++) p[i] = coefficients[i];
    p[0] += NTT_MOD - a;
    p[0] %= NTT_MOD;
    return p;
  }
  Polynomial operator*(unsigned long long mult) {
    Polynomial p(deg);
    for (int i = 0; i < (deg + 1); i++) p[i] = coefficients[i] * mult % NTT_MOD;
    return p;
  }
  Polynomial operator/(unsigned long long div) { return *this * invMod(div); }
  Polynomial operator+(Polynomial b) {
    Polynomial res(max(deg, b.deg));
    for (int i = 0; i < (max(deg, b.deg) + 1); i++)
      res[i] = (((i > deg) ? 0 : coefficients[i]) + ((i > b.deg) ? 0 : b[i])) %
               NTT_MOD;
    return res;
  }
  Polynomial operator-(Polynomial p) { return *this + (p * (NTT_MOD - 1)); }
  Polynomial operator*(Polynomial b) {
    vector<unsigned long long> va, vb;
    for (int i = 0; i < (deg + 1); i++) va.push_back((*this)[i]);
    for (int i = 0; i < (b.deg + 1); i++) vb.push_back(b[i]);
    vector<unsigned long long> vc = NTT::conv(va, vb);
    Polynomial res(vc.size() - 1);
    for (int i = 0; i < (vc.size()); i++) res[i] = vc[i];
    return res;
  }
  void operator+=(unsigned long long a) {
    coefficients[0] += a, coefficients[0] %= NTT_MOD;
  }
  void operator-=(unsigned long long a) { *this += NTT_MOD - a; }
  void operator*=(unsigned long long mult) {
    for (int i = 0; i < (deg + 1); i++)
      coefficients[i] *= mult, coefficients[i] %= NTT_MOD;
  }
  void operator/=(unsigned long long div) { *this *= invMod(div); }
  void operator+=(Polynomial b) { *this = *this + b; }
  void operator-=(Polynomial p) { *this = *this - p; }
  void operator*=(Polynomial b) { *this = *this * b; }
  unsigned long long& operator[](int idx) { return coefficients[idx]; }
};
int N, A, B;
long long C(long long n, long long r) {
  long long res = 1;
  long long div = 1;
  for (int i = 0; i < (r); i++) res = res * (n - i) % NTT_MOD;
  for (int i = (1); i < (r + 1); i++) div = div * i % NTT_MOD;
  return res * invMod(div) % NTT_MOD;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cin >> N >> A >> B;
  if (A + B - 2 > N - 1 || A == 0 || B == 0) {
    cout << 0 << endl;
    return 0;
  }
  queue<Polynomial> q;
  Polynomial strt(0);
  strt[0] = 1;
  q.push(strt);
  for (int i = 0; i < (N - 1); i++) {
    Polynomial mult(1);
    mult[1] = 1;
    mult[0] = i;
    q.push(mult);
  }
  while (q.size() > 1) {
    Polynomial a = q.front();
    q.pop();
    Polynomial b = q.front();
    q.pop();
    q.push(a * b);
  }
  cout << q.front()[A + B - 2] * C(A + B - 2, A - 1) % NTT_MOD << endl;
  return 0;
}

5 2 2
 2 1 1
 1 1 1
 2 2 1
 71403 24106 70541
 89432 40000 50000
 1000 50 100
 50000 4000 8000
 97231 16000 5000
 25987 6086 25465
 3000 200 500
 10 3 4
 4555 4504 1763
 13494 13483 4308
 20683 11157 956
 100000 65144 59119
 6321 23 21
 30070 29651 2504
 93421 5672 2331
 59139 20702 51540
 10 4 0
 7321 246 246
 100000 98854 36811
 71841 9132 56590
 21569 10670 16773
 96022 82557 36142
 10 0 5
 29174 24786 28767
 87321 23421 16798
 46646 19345 26662
 80000 4000 1000
 53932 44140 10243
 70955 52821 31261
 100000 73195 13158
 98992 4321 1234
 87531 85922 46741
 18 7 3
 13046 8030 2007
 96918 16438 63621
 100000 11677 24972
 72289 29725 31246
 88417 6561 51466
 100000 60521 62422
 79446 66774 63154
 70945 20718 38408
 54817 4774 19136
 9859 7515 9594
 1000 200 400
 100000 76661 42976
 30518 286 7425
 2800 1100 300
 1 0 1
 37803 31419 15385
 5440 4704 361
 25539 18794 9283
 90000 4000 0
 8123 309 201
 91939 25467 48723
 76259 75251 50938
 9411 2851 7246
 8515 3598 1521
 70060 60809 2240
 71393 5069 42846
 54369 5132 6743
 79894 51443 61094
 54379 50959 2990
 100000 62832 44419
 92387 47939 16068
 100000 20000 30000
 87969 7717 29416
 90000 10000 20000
 100000 13988 63865
 100000 24351 8412
 100000 75506 27858
 89432 40000 31577
 1000 93 100
 50000 3912 8000
 2795 200 500
 14 3 4
 4555 2504 1763
 20683 11157 999
 100000 65144 97576
 6321 23 5
 93421 8799 2331
 7321 95 246
 71841 9132 41806
 87321 4347 16798
 73940 19345 26662
 80000 2870 1000
 53932 38095 10243
 98992 1903 1234
 92303 16438 63621
 88417 6561 39585
 79446 66774 9430
 54817 8855 19136
 100000 45723 42976
 30518 547 7425
 3454 1100 300
 37803 7574 15385
 10308 4704 361
 41571 18794 9283
 8123 553 201
 91939 25467 19783
 8515 2085 1521
 71393 5069 11438
 54369 5132 10034
 30070 29651 1578
 61384 20702 51540
 10 2 0
 100000 98854 42598
 21569 11396 16773
 96022 82557 43270
 10 0 8
 87531 85922 21778
 33510 29725 31246
 70945 20718 62819
 2 0 1
 60891 60809 2240
 79894 52959 61094

22
 0
 1
 1
 0
 0
 453675291
 270228483
 709432083
 0
 770478666
 224490
 0
 0
 225513895
 0
 347710549
 0
 145626023
 0
 0
 880024306
 0
 323303988
 0
 0
 0
 0
 192981221
 399251611
 621308120
 0
 0
 844798898
 404637040
 0
 713347127
 257847478
 40670475
 824322516
 827204894
 35391565
 0
 0
 142555896
 395115866
 0
 464127228
 0
 72411772
 578139363
 0
 0
 285813325
 0
 0
 821177915
 446294322
 0
 0
 51885663
 93164516
 517003284
 589010691
 0
 838960076
 0
 528299725
 951117171
 218793443
 666909638
 299290270
 979520815
 0
 869172487
 299611008
 357578392
 73376903
 582602242
 22349024
 751540062
 0
 669596469
 209774351
 992431938
 570179592
 242819523
 850476362
 702620010
 356161759
 761816370
 74025273
 238293417
 589892999
 522982567
 715770394
 40889585
 653048494
 552485010
 77156807
 277831457
 702047521
 596044210
 540350700
 333525026
 371895856
 0
 0
 0
 0
 0
 0
 0
 0
 0
 0
 0
 0
 0
