output_description: Print the number of different sequences that can result after M operations,
  modulo 998244353.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
attempt: class Combination:
      """階乗とその逆元のテーブルをO(N)で事前作成し、組み合わせの計算をO(1)で行う"""
  
      def __init__(self, n, MOD):
          self.fact = [1]
          for i in range(1, n + 1):
              self.fact.append(self.fact[-1] * i % MOD)
          self.inv_fact = [0] * (n + 1)
          self.inv_fact[n] = pow(self.fact[n], MOD - 2, MOD)
          for i in reversed(range(n)):
              self.inv_fact[i] = self.inv_fact[i + 1] * (i + 1) % MOD
          self.MOD = MOD
  
      def inverse(self, k):
          """kの逆元を求める O(1)"""
          return (self.inv_fact[k] * self.fact[k - 1]) % self.MOD
  
      def factorial(self, k):
          """k!を求める O(1)"""
          return self.fact[k]
  
      def inverse_factorial(self, k):
          """k!の逆元を求める O(1)"""
          return self.inv_fact[k]
  
      def permutation(self, k, r):
          """kPrを求める O(1)"""
          if k < r:
              return 0
          return (self.fact[k] * self.inv_fact[k - r]) % self.MOD
  
      def combination(self, k, r):
          """kCrを求める O(1)"""
          if k < r:
              return 0
          return (self.fact[k] * self.inv_fact[k - r] * self.inv_fact[r]) % self.MOD
  
  
  n, m = map(int, input().split())
  MOD = 998244353
  comb = Combination(10**7, MOD)
  
  
  ans = 0
  for odd_cnt in range(m + 1):
      if odd_cnt > n:
          continue
      if (3 * m - odd_cnt) % 2 == 1:
          continue
      ptn = 1
      box = n
      odd_ball = odd_cnt
      ptn *= comb.combination(box, odd_ball)
  
      even_pair_ball = (3 * m - odd_cnt) // 2
      ptn *= comb.combination(even_pair_ball + box - 1, even_pair_ball)
  
      ans += ptn
      ptn %= MOD
  
  for i in range(1, m + 1):
      ball = m - i
      box = n - 1
      ans -= comb.combination(ball + box - 1, ball) * n
      ans %= MOD
  
  print(ans)
  
problem_description: Statement
  
  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.
samples: [{"input": "2 2", "output": "3\n    \n\nAfter two operations, there are three possible outcomes:\n\n  * x=(2,4)\n  * x=(3,3)\n  * x=(4,2)\n\nFor example, x=(3,3) can result after the following sequence of operations:\n\n  * First, choose i=0,j=1, changing x from (0,0) to (2,1).\n  * Second, choose i=1,j=0, changing x from (2,1) to (3,3).\n\n* * *"}, {"input": "3 2", "output": "19\n    \n\n* * *"}, {"input": "10 10", "output": "211428932\n    \n\n* * *"}, {"input": "100000 50000", "output": "3463133"}]