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

Solution (in CPP):

Solution:
#include <cstdio>
#include <vector>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = (int) 3e6 + 10;
const long long MOD = 998244353;

int n, m;
long long f[N], g[N];

long long fpow(long long x, long long y) {
	if (y == 0) {
		return 1LL;
	}
	if (y % 2 == 0) {
		return fpow(x * x % MOD, y / 2);
	} else {
		return x * fpow(x, y - 1) % MOD;
	}
}

long long choose(int n, int m) {
	if (n < 0 || m < 0 || m > n) {
		return 0LL;
	}
	/*memset(c, 0, sizeof c);
	c[0][0] = 1;
	for (int i = 0; i < 50; i++) {
		c[i][0] = 1;
		for (int j = 1; j <= i; j++) {
			c[i][j] = c[i-1][j-1]+c[i-1][j];
		}
	}
	return c[n][m];*/
	long long ret = (f[n] * g[m] % MOD) * g[n - m] % MOD;
	//printf("dbg %d %d %lld\n",n,m,ret);
	return ret;
}

long long calc(int n, int s, int m) {
	long long res = 0;
	for (int i = 0; i <= n && i <= m; i++) {
		int j = s - i;
		if (j >= 0 && j % 2 == 0) {
			long long u = choose(n, i);
			long long v = choose(j / 2 + n - 1, n - 1);
			res = (res + u * v) % MOD;
		}
	}
	return res;
}

int main() {

	f[0] = 1;

	for (int i = 1; i < N; i++) {
		f[i] = f[i - 1] * i % MOD;
	}

	g[N - 1] = fpow(f[N - 1], MOD - 2);

	for (int i = N - 2; i >= 0; i--) {
		g[i] = g[i + 1] * (i + 1) % MOD;
	}

	scanf("%d %d", &n, &m);

	long long res = calc(n, 3 * m, m) - (calc(n, m, m) - calc(n - 1, m, m)) * n % MOD;

	printf("%lld\n", (res % MOD + MOD) % MOD);

	return 0;

}