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
#include<iostream>
#include<iomanip>
#include<cmath>
#include<string>
#include<cstring>
#include<vector>
#include<list>
#include<algorithm>
#include<map>
#include<set>
#include<queue>
#include<stack>
using namespace std;
typedef long long ll;
#define fi first
#define se second
#define mp make_pair
#define mt make_tuple
#define pqueue priority_queue
const int inf=1e9+7;
const ll mod=1e9+7;
const ll mod1=998244353;
const ll big=1e18;
const double PI=2*asin(1);

ll frac[10000000];

ll comb(ll a, ll b) {
  if(a<b) return 0;
  ll ans = frac[a];
  ll sh1, sh2;
  ll two;
  ll h = mod1-2;
  while(h>0) {
    two = 1;
    sh1 = frac[b];
    sh2 = frac[a-b];
    while(2*two<h) {
      two *= 2;
      sh1 *= sh1;
      sh1 %= mod1;
      sh2 *= sh2;
      sh2 %= mod1;
    }
    h -= two;
    ans *= sh1*sh2%mod1;
    ans %= mod1;
  }
  return ans;
}

int main() {
  frac[0] = 1;
  for(ll i=1;i<10000000;++i) frac[i] = frac[i-1]*i%mod1;
  ll N, M;
  cin>>N>>M;
  ll ans = comb(3*M+N-1, N-1);
  for(ll i=2*M+1;i<=3*M;++i) {
    ans = (ans-N*comb(3*M-i+N-2, N-2)%mod1+mod1)%mod1;
  }
  for(ll i=0;i<M;++i) {
    ans = (ans-comb(i+N-1, N-1)*comb(N, 3*M-2*i)%mod1+mod1)%mod1;
  }
  cout<<ans<<endl;
}

