#include <bits/stdc++.h>
#define N 998244353
#define MAX 5000000
using namespace std;

long long factorial[MAX] = {0}, finverse[MAX] = {0},
          inverse[MAX] = {0};

void smodfact() {
  factorial[0] = factorial[1] = 1;
  finverse[0] = finverse[1] = 1;
  inverse[1] = 1;
  for(int i = 2; i < MAX; ++i) {
    factorial[i] = factorial[i - 1] * i % N;
    inverse[i] = N - (inverse[N % i] * (N / i)) % N;
    finverse[i] = finverse[i - 1] * inverse[i] % N;
  }
}

long long calccomb(long long n, long long k) {
  if(n == k && n == 0) return 1;
  if(n < 0 || k < 0 || n < k) return 0;
  return factorial[n] * finverse[k] % N * finverse[n - k] %
         N;
}

long long n, m;

long long solve();

int main() {
  smodfact();
  cin >> n >> m;

  cout << solve() << endl;
  return 0;
}

long long solve() {
  long long ans = 0;
  for(int i = 0; i <= min(m, n); ++i)
    if((m - i) % 2 == 0) {
      long long now = calccomb(n, i),
                dummy1 = calccomb(n - 1, i - 1) * n % N,
                dummy2 = calccomb(n - 1, i) * n % N;
      now *= calccomb(m + (m - i) / 2 + n - 1, n - 1);
      now %= N;
      // dummy1
      dummy1 *= calccomb((m - i) / 2 + n - 1, n - 1);
      dummy1 %= N;
      now -= dummy1;
      while(now < 0) now += N;
      // dummy2
      dummy2 *= calccomb((m - i) / 2 - 1 + n - 1, n - 1);
      dummy2 %= N;
      now -= dummy2;
      while(now < 0) now += N;
      ans += now;
      ans %= N;
    }
  return ans;
}
### Prompt

In CPP, your task is to solve the following problem:

We have a sequence of N integers: x=(x_0,x_1,\cdots,x_{N-1}). Initially, x_i=0 for each i (0 \leq i \leq N-1).

Snuke will perform the following operation exactly M times:

* Choose two distinct indices i, j (0 \leq i,j \leq N-1,\ i \neq j). Then, replace x_i with x_i+2 and x_j with x_j+1.



Find the number of different sequences that can result after M operations. Since it can be enormous, compute the count modulo 998244353.

Constraints

* 2 \leq N \leq 10^6
* 1 \leq M \leq 5 \times 10^5
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N M


Output

Print the number of different sequences that can result after M operations, modulo 998244353.

Examples

Input

2 2


Output

3


Input

3 2


Output

19


Input

10 10


Output

211428932


Input

100000 50000


Output

3463133

### Response

```cpp
#include <bits/stdc++.h>
#define N 998244353
#define MAX 5000000
using namespace std;

long long factorial[MAX] = {0}, finverse[MAX] = {0},
          inverse[MAX] = {0};

void smodfact() {
  factorial[0] = factorial[1] = 1;
  finverse[0] = finverse[1] = 1;
  inverse[1] = 1;
  for(int i = 2; i < MAX; ++i) {
    factorial[i] = factorial[i - 1] * i % N;
    inverse[i] = N - (inverse[N % i] * (N / i)) % N;
    finverse[i] = finverse[i - 1] * inverse[i] % N;
  }
}

long long calccomb(long long n, long long k) {
  if(n == k && n == 0) return 1;
  if(n < 0 || k < 0 || n < k) return 0;
  return factorial[n] * finverse[k] % N * finverse[n - k] %
         N;
}

long long n, m;

long long solve();

int main() {
  smodfact();
  cin >> n >> m;

  cout << solve() << endl;
  return 0;
}

long long solve() {
  long long ans = 0;
  for(int i = 0; i <= min(m, n); ++i)
    if((m - i) % 2 == 0) {
      long long now = calccomb(n, i),
                dummy1 = calccomb(n - 1, i - 1) * n % N,
                dummy2 = calccomb(n - 1, i) * n % N;
      now *= calccomb(m + (m - i) / 2 + n - 1, n - 1);
      now %= N;
      // dummy1
      dummy1 *= calccomb((m - i) / 2 + n - 1, n - 1);
      dummy1 %= N;
      now -= dummy1;
      while(now < 0) now += N;
      // dummy2
      dummy2 *= calccomb((m - i) / 2 - 1 + n - 1, n - 1);
      dummy2 %= N;
      now -= dummy2;
      while(now < 0) now += N;
      ans += now;
      ans %= N;
    }
  return ans;
}
```