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<bits/stdc++.h>
#define ll long long

using namespace std;

const int N = 1e6+1, M = 5e5, F = 4*N, mod = 998244353;

ll binpow(ll a, ll s){
    ll ans = 1;
    while(s){
        if(s&1)
            ans = ans*a%mod;
        a = a*a%mod;
        s >>= 1;
    }
    return ans;
}

ll inv(ll a){
    return binpow(a, mod-2);
}

int n, m;
ll f[F], invf[F];
void init(){
    f[0] = 1;
    invf[0] = 1;
    for(int i = 1; i < F; ++i){
        f[i] = f[i-1]*i%mod;
        invf[i] = inv(f[i]);
    }
}

ll C(int n, int k){
    if(n < k || k < 0)
        return 0ll;
    return f[n]*invf[n-k]%mod*invf[k]%mod;
}

ll C_(int n, int k){
    return C(n+k-1, k);
}

int main(){
    ios_base::sync_with_stdio(false);
    cout.tie(0);
    cin.tie(0);
    init();
    cin >> n >> m;
    ll ans = 0;
    for(int odd = m; odd >= 0; odd -= 2){
        if(odd > n)
            continue;
        ll cnt2 = m+(m-odd)/2;
        ll res = C(n, odd)*C_(n, cnt2)%mod;
        res = (res - (C_(n, cnt2-m-1)*C(n-1, odd)%mod + C_(n, cnt2-m)*C(n-1, odd-1)%mod)*n%mod)%mod;
        ans = (ans+res)%mod;
    }
    if(ans < 0) ans += mod;
    cout << ans << '\n';
}