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 <vector>
#include <cassert>
using namespace std;
typedef long long ll;

ll inf = 998244353;
ll fact[3000010] = {0};
ll finv[3000010] = {0};
ll inv[3000010] = {0};

ll mult(ll n, ll m){
	if(m==1) return n%inf;
	else if(m%2==0){
		ll t = mult(n,m/2);
		return t*t%inf;
	}else{
		ll t = mult(n,m-1);
		return t*n%inf;
	}
}

void factorial(ll N){
	fact[0] = fact[1] = 1;
	finv[0] = finv[1] = 1;
	inv[1] = 1;
	for(ll i=2;i<=N;i++){
		fact[i] = i*fact[i-1]%inf;
		inv[i] = inf-inv[inf%i]*(inf/i)%inf;
		finv[i] = finv[i-1]*inv[i]%inf;
	}
}

ll comb(ll n,ll k){
	if(n<k) return 0;
	if(n<0 || k<0) return 0;
	else return (((fact[n]*finv[k])%inf)*finv[n-k])%inf;
}

ll hcomb(ll n,ll k){
	if(n==0 && k==0) return 1;
	return comb(n+k-1,k);
}

int main(){
    ll N,M;
    cin >> N >> M;
    factorial(N+3*M);
	ll ans = hcomb(N,3*M);
	for(ll k=M+1;k<=min(N,3*M);k++){
		if((3*M-k)%2==1) continue;
		(ans += -comb(N,k)*hcomb(N,(3*M-k)/2)%inf+inf)%=inf;
	}
	(ans += -hcomb(N,M-1)*N%inf+inf)%=inf;
	cout << ans << endl;
}