#include <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int> >
#define vvl std::vector<std::vector<ll> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;

////////////////////////////////
#define P 998244353
#define N_MAX 10000000
typedef long long int ll;
ll fac[N_MAX+1];
ll inv[N_MAX+1];
ll finv[N_MAX+1];

ll comb(ll n, ll k){
    return (((fac[n]*finv[n-k])%P)*finv[k])%P;
}
void init(){
    fac[0] = finv[0] = fac[1] = finv[1] = inv[1] = 1;
    for(int i = 2; i <= N_MAX; i++){
        fac[i] = (fac[i-1]*i)%P;
        inv[i] = ((-(P/i)*inv[P%i])%P+P)%P;
        finv[i] = (finv[i-1]*inv[i])%P;
    }
}
ll pp(ll a, ll b){return (a * b)%P;}
ll pm(ll a, ll b){return (a>b?a-b:(a-b+P)%P);}
//////////////////////////////////////
int main(int argc, char const *argv[]) {
  ll N, M, ans = 0;
  std::cin >> N >> M;
  init();
  for(int i=0;i<=min(M, N);i++){
    if((3*M-i)%2==1) continue;
    ll tmp = pp(comb(N, i), comb((3*M-i)/2+N-1, N-1));
    ll tmp2 = pp(pp(comb(N, i), i), comb((M-i)/2+N-1, N-1));
    ll tmp3 = (i==M?0:pp(pp(comb(N, i), N-i), comb((M-i-2)/2+N-1, N-1)));
    //std::cout << "now" << i << " " <<  tmp << " " << tmp2 << " " << tmp3<< '\n';
    ans = (ans+pm(pm(tmp, tmp2), tmp3))%P;
  }
  std::cout << ans << '\n';
  return 0;
}

### Prompt

Construct a CPP code solution to the problem outlined:

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 <iostream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <algorithm>
#include <set>
#include <map>
#define vv(a, b, c, d) vector<vector<d> >(a, vector<d>(b, c))
#define vvi std::vector<std::vector<int> >
#define vvl std::vector<std::vector<ll> >
#define MODs 1000000007;
typedef long long int ll;
using namespace std;

////////////////////////////////
#define P 998244353
#define N_MAX 10000000
typedef long long int ll;
ll fac[N_MAX+1];
ll inv[N_MAX+1];
ll finv[N_MAX+1];

ll comb(ll n, ll k){
    return (((fac[n]*finv[n-k])%P)*finv[k])%P;
}
void init(){
    fac[0] = finv[0] = fac[1] = finv[1] = inv[1] = 1;
    for(int i = 2; i <= N_MAX; i++){
        fac[i] = (fac[i-1]*i)%P;
        inv[i] = ((-(P/i)*inv[P%i])%P+P)%P;
        finv[i] = (finv[i-1]*inv[i])%P;
    }
}
ll pp(ll a, ll b){return (a * b)%P;}
ll pm(ll a, ll b){return (a>b?a-b:(a-b+P)%P);}
//////////////////////////////////////
int main(int argc, char const *argv[]) {
  ll N, M, ans = 0;
  std::cin >> N >> M;
  init();
  for(int i=0;i<=min(M, N);i++){
    if((3*M-i)%2==1) continue;
    ll tmp = pp(comb(N, i), comb((3*M-i)/2+N-1, N-1));
    ll tmp2 = pp(pp(comb(N, i), i), comb((M-i)/2+N-1, N-1));
    ll tmp3 = (i==M?0:pp(pp(comb(N, i), N-i), comb((M-i-2)/2+N-1, N-1)));
    //std::cout << "now" << i << " " <<  tmp << " " << tmp2 << " " << tmp3<< '\n';
    ans = (ans+pm(pm(tmp, tmp2), tmp3))%P;
  }
  std::cout << ans << '\n';
  return 0;
}

```