zscoder has a deck of n+m custom-made cards, which consists of n cards labelled from 1 to n and m jokers. Since zscoder is lonely, he wants to play a game with himself using those cards. 

Initially, the deck is shuffled uniformly randomly and placed on the table. zscoder has a set S which is initially empty. 

Every second, zscoder draws the top card from the deck. 

  * If the card has a number x written on it, zscoder removes the card and adds x to the set S. 
  * If the card drawn is a joker, zscoder places all the cards back into the deck and reshuffles (uniformly randomly) the n+m cards to form a new deck (hence the new deck now contains all cards from 1 to n and the m jokers). Then, if S currently contains all the elements from 1 to n, the game ends. Shuffling the deck doesn't take time at all. 



What is the expected number of seconds before the game ends? We can show that the answer can be written in the form P/Q where P, Q are relatively prime integers and Q ≠ 0 mod 998244353. Output the value of (P ⋅ Q^{-1}) modulo 998244353.

Input

The only line of the input contains two integers n and m (1 ≤ n, m ≤ 2 ⋅ 10^{6}).

Output

Output a single integer, the value of (P ⋅ Q^{-1}) modulo 998244353.

Examples

Input


2 1


Output


5


Input


3 2


Output


332748127


Input


14 9


Output


969862773

Note

For the first sample, it can be proven that the expected time before the game ends is 5 seconds.

For the second sample, it can be proven that the expected time before the game ends is 28/3 seconds.
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
__inline__ __attribute__((always_inline)) unsigned int rnd() {
  static unsigned int seed = 416;
  return seed ^= seed >> 5, seed ^= seed << 17, seed ^= seed >> 13;
}
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
  return (!b) ? a : gcd(b, a % b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp abs(const _Tp &a) {
  return a >= 0 ? a : -a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b) {
  return a < b ? b : a;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b) {
  return a < b ? a : b;
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmax(_Tp &a, const _Tp &b) {
  (a < b) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void chmin(_Tp &a, const _Tp &b) {
  (b < a) && (a = b);
}
template <typename _Tp>
__inline__ __attribute__((always_inline)) void read(_Tp &x) {
  char ch(getchar());
  bool f(false);
  while (ch < 48 || ch > 57) f |= ch == 45, ch = getchar();
  x = ch & 15, ch = getchar();
  while (ch >= 48 && ch <= 57)
    x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
  if (f) x = -x;
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) void read(_Tp &t, Args &...args) {
  read(t);
  read(args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp min(const _Tp &a, const _Tp &b,
                                                  const Args &...args) {
  return a < b ? min(a, args...) : min(b, args...);
}
template <typename _Tp, typename... Args>
__inline__ __attribute__((always_inline)) _Tp max(const _Tp &a, const _Tp &b,
                                                  const Args &...args) {
  return a < b ? max(b, args...) : max(a, args...);
}
__inline__ __attribute__((always_inline)) int read_str(char *s) {
  char ch(getchar());
  while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
  char *tar = s;
  *tar = ch, ch = getchar();
  while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
    *(++tar) = ch, ch = getchar();
  return tar - s + 1;
}
const int N = 4000005;
const int mod = 998244353;
template <typename _Tp1, typename _Tp2>
__inline__ __attribute__((always_inline)) void add(_Tp1 &a, _Tp2 b) {
  (a += b) >= mod && (a -= mod);
}
template <typename _Tp1, typename _Tp2>
__inline__ __attribute__((always_inline)) void sub(_Tp1 &a, _Tp2 b) {
  (a -= b) < 0 && (a += mod);
}
long long ksm(long long a, long long b = mod - 2) {
  long long res = 1;
  while (b) {
    if (b & 1) res = res * a % mod;
    a = a * a % mod, b >>= 1;
  }
  return res;
}
long long fac[N], inv[N], ifac[N];
void init() {
  fac[0] = fac[1] = inv[0] = inv[1] = ifac[0] = ifac[1] = 1;
  for (int i = 2; i < N; ++i) {
    fac[i] = fac[i - 1] * i % mod;
    inv[i] = inv[mod % i] * (mod - mod / i) % mod;
    ifac[i] = ifac[i - 1] * inv[i] % mod;
  }
}
__inline__ __attribute__((always_inline)) long long C(int n, int m) {
  return fac[n] * ifac[m] % mod * ifac[n - m] % mod;
}
long long f[N], a[N], b[N];
long long s1[N], s2[N], s3[N];
int main() {
  init();
  long long n, m;
  read(n, m);
  long long mul = 1;
  for (int i = 1; i <= n; ++i)
    a[i] = mod + 1 -
           m * fac[n - i] % mod * ifac[n + m] % mod * C(n + m, m + i) % mod *
               fac[m + i - 1] % mod,
    mul = mul * a[i] % mod;
  mul = ksm(mul);
  for (int i = n; i >= 1; --i) b[i] = mul, mul = mul * a[i] % mod;
  mul = 1;
  for (int i = 1; i <= n; ++i) b[i] = b[i] * mul % mod, mul = mul * a[i] % mod;
  s1[0] = fac[m - 1];
  for (int i = 1; i <= n; ++i) {
    s1[i] = s1[i - 1], add(s1[i], fac[m + i - 1] * ifac[i] % mod);
    s2[i] = s2[i - 1], add(s2[i], fac[m + i - 1] * ifac[i - 1] % mod);
    long long _ = m * fac[i] % mod * fac[n - i] % mod * ifac[n + m] % mod;
    long long tmp = _ * C(n + m + 1, m + i + 1) % mod *
                    (s1[i] * (i + 1) % mod - s2[i] + mod) % mod;
    f[i] = (tmp + _ * C(n + m, m + i) % mod * s3[i] % mod) * b[i] % mod;
    s3[i + 1] = s3[i],
           add(s3[i + 1], fac[m + i - 1] * ifac[i] % mod * f[i] % mod);
  }
  printf("%lld\n", f[n]);
  return 0;
}
