#include <bits/stdc++.h>
#define ll long long
#define maxn 2000005
#define mod 998244353
using namespace std;

ll n, m;
ll fac[maxn];

ll power(ll x, ll y)
{
    ll res = 1;
    while (y)
    {
        if (y & 1)
            res = res * x % mod;
        x = x * x % mod;
        y /= 2;
    }
    return res;
}
ll inv(ll x)
{
    return power(x, mod - 2);
}

ll cal(ll N, ll T)
{
    ll res = 0;
    for (int k = 0; k <= m; k++)
    {
        if ((T - k) % 2 != 0)
            continue;
        if (N < k || T < k)
            break;
        ll now = N * inv(fac[k]) % mod * inv(fac[N - k]) % mod;
        now = now * fac[N + (T - k) / 2 - 1] % mod * inv(fac[(T - k) / 2]) % mod;
        res = (res + now) % mod;
    }
    return res;
}

int main()
{
    fac[0] = 1;
    for (int i = 1; i < maxn; i++)
        fac[i] = fac[i - 1] * i % mod;

    cin >> n >> m;
    ll ans = cal(n, 3 * m);
    ll mi = (cal(n, m) + mod - cal(n - 1, m)) % mod;
    mi = n * mi % mod;
    ans = (ans + mod - mi) % mod;
    printf("%lld", ans);

    return 0;
}

### 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 <bits/stdc++.h>
#define ll long long
#define maxn 2000005
#define mod 998244353
using namespace std;

ll n, m;
ll fac[maxn];

ll power(ll x, ll y)
{
    ll res = 1;
    while (y)
    {
        if (y & 1)
            res = res * x % mod;
        x = x * x % mod;
        y /= 2;
    }
    return res;
}
ll inv(ll x)
{
    return power(x, mod - 2);
}

ll cal(ll N, ll T)
{
    ll res = 0;
    for (int k = 0; k <= m; k++)
    {
        if ((T - k) % 2 != 0)
            continue;
        if (N < k || T < k)
            break;
        ll now = N * inv(fac[k]) % mod * inv(fac[N - k]) % mod;
        now = now * fac[N + (T - k) / 2 - 1] % mod * inv(fac[(T - k) / 2]) % mod;
        res = (res + now) % mod;
    }
    return res;
}

int main()
{
    fac[0] = 1;
    for (int i = 1; i < maxn; i++)
        fac[i] = fac[i - 1] * i % mod;

    cin >> n >> m;
    ll ans = cal(n, 3 * m);
    ll mi = (cal(n, m) + mod - cal(n - 1, m)) % mod;
    mi = n * mi % mod;
    ans = (ans + mod - mi) % mod;
    printf("%lld", ans);

    return 0;
}

```