#include<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#define N_ 3010000
using namespace std;
int n, m;
map<vector<int>, int>Map;
long long F[N_], InvF[N_], Mod = 998244353;
long long T[N_];
vector<int>TP;
long long Pow(long long a, long long b) {
	long long r = 1;
	while (b) {
		if (b & 1)r = r * a%Mod;
		a = a * a%Mod; b >>= 1;
	}
	return r;
}
long long Comb(long long a, long long b) {
	if (a < b || b < 0)return 0ll;
	return F[a] * InvF[b] % Mod*InvF[a - b] % Mod;
}
long long H(int a, int b) {
	if (a == 0 && b == 0)return 1ll;
	if (a == 0)return 0ll;
	return F[a + b - 1] * InvF[b] % Mod * InvF[a - 1] % Mod;
}
int r2 = 0;
void DFS(int a) {
	if (a == 0) {
		if (Map.count(TP))return;
		Map[TP] = 1;
		r2++;
		return;
	}
	int i, j;
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++) {
			if (i != j) {
				TP[i]++;
				TP[j] += 2;
				DFS(a - 1);
				TP[i]--;
				TP[j] -= 2;
			}
		}
	}
}
int main() {
	scanf("%d%d", &n, &m);
	int i;
	F[0] = 1;
	for (i = 1; i < N_; i++) F[i] = F[i - 1] * i%Mod;
	InvF[N_ - 1] = Pow(F[N_ - 1], Mod - 2);
	for (i = N_ - 1; i >= 1; i--)InvF[i - 1] = InvF[i] * i%Mod;
	long long res = H(n, 3 * m);
	res = (res - n * H(n, m - 1) % Mod + Mod) % Mod;
	long long ss = 0;
	for (i = m + 1; i <= 3 * m; i++) {
		if (i > n || 3*m%2!=i%2)continue;
		long long t = Comb(n, i) * H(n, (3 * m - i)/2) % Mod;
		res = (res - t + Mod) % Mod;
	}
	printf("%lld\n", res);
}
### Prompt

Create a solution in CPP for 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<cstdio>
#include<algorithm>
#include<vector>
#include<map>
#define N_ 3010000
using namespace std;
int n, m;
map<vector<int>, int>Map;
long long F[N_], InvF[N_], Mod = 998244353;
long long T[N_];
vector<int>TP;
long long Pow(long long a, long long b) {
	long long r = 1;
	while (b) {
		if (b & 1)r = r * a%Mod;
		a = a * a%Mod; b >>= 1;
	}
	return r;
}
long long Comb(long long a, long long b) {
	if (a < b || b < 0)return 0ll;
	return F[a] * InvF[b] % Mod*InvF[a - b] % Mod;
}
long long H(int a, int b) {
	if (a == 0 && b == 0)return 1ll;
	if (a == 0)return 0ll;
	return F[a + b - 1] * InvF[b] % Mod * InvF[a - 1] % Mod;
}
int r2 = 0;
void DFS(int a) {
	if (a == 0) {
		if (Map.count(TP))return;
		Map[TP] = 1;
		r2++;
		return;
	}
	int i, j;
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++) {
			if (i != j) {
				TP[i]++;
				TP[j] += 2;
				DFS(a - 1);
				TP[i]--;
				TP[j] -= 2;
			}
		}
	}
}
int main() {
	scanf("%d%d", &n, &m);
	int i;
	F[0] = 1;
	for (i = 1; i < N_; i++) F[i] = F[i - 1] * i%Mod;
	InvF[N_ - 1] = Pow(F[N_ - 1], Mod - 2);
	for (i = N_ - 1; i >= 1; i--)InvF[i - 1] = InvF[i] * i%Mod;
	long long res = H(n, 3 * m);
	res = (res - n * H(n, m - 1) % Mod + Mod) % Mod;
	long long ss = 0;
	for (i = m + 1; i <= 3 * m; i++) {
		if (i > n || 3*m%2!=i%2)continue;
		long long t = Comb(n, i) * H(n, (3 * m - i)/2) % Mod;
		res = (res - t + Mod) % Mod;
	}
	printf("%lld\n", res);
}
```