output_description: Print 2K-1 integers. The t-th of them (1\leq t\leq 2K-1) should be the answer
  for i=t+1.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      K N
attempt: import sys
  
  stdin = sys.stdin
  
  
  def li():
      return map(int, stdin.readline().split())
  
  
  def li_():
      return map(lambda x: int(x) - 1, stdin.readline().split())
  
  
  def lf():
      return map(float, stdin.readline().split())
  
  
  def ls():
      return stdin.readline().split()
  
  
  def ns():
      return stdin.readline().rstrip()
  
  
  def lc():
      return list(ns())
  
  
  def ni():
      return int(stdin.readline())
  
  
  def nf():
      return float(stdin.readline())
  
  
  # nの逆元のリスト
  def inv_mod(n: int, mod: int) -> list:
      inv = [0, 1]
      for i in range(2, n + 1):
          inv.append(mod - ((mod // i) * inv[mod % i]) % mod)
      return inv
  
  
  # nの階乗のリスト
  def fact(n: int, mod: int) -> list:
      fac = [1, 1]
      res = 1
      for i in range(2, n + 1):
          res = res * i % mod
          fac.append(res)
      return fac
  
  
  # nの階乗の逆元のリスト
  def fact_inv(n: int, inv: list, mod: int) -> list:
      facInv = [1, 1]
      for i in range(2, n + 1):
          facInv.append(facInv[i - 1] * inv[i] % mod)
      return facInv
  
  
  # 二項係数
  def nCr(n: int, r: int, mod: int, fac: list, facInv: list) -> int:
      if not (0 <= r and r <= n):
          return 0
  
      return ((fac[n] * facInv[r]) % mod) * facInv[n - r] % mod
  
  
  MOD = 998244353
  
  k, n = li()
  
  inv = inv_mod(n + k, MOD)
  fac = fact(n + k, MOD)
  facInv = fact_inv(n + k, inv, MOD)
  
  answers = []
  if k == 1:
      print(0)
  
  else:
      for t in range(2, k + 2):
          p = t // 2
          ans = 0
          if t % 2 == 0:
              temp = 0
              for q in range(p):
                  temp = temp + nCr(p - 1, q, MOD, fac, facInv) * (2**q) * nCr(
                      n + k - 2 * p, n - q, MOD, fac, facInv
                  )
                  temp %= MOD
  
                  temp = temp + nCr(p - 1, q, MOD, fac, facInv) * (2**q) * nCr(
                      n + k - 2 * p - 1, n - q - 1, MOD, fac, facInv
                  )
                  temp %= MOD
  
              ans = temp % MOD
  
          else:
              temp = 0
              for q in range(p + 1):
                  temp = temp + nCr(p, q, MOD, fac, facInv) * (2**q) * nCr(
                      n + k - 2 * p - 1, n - q, MOD, fac, facInv
                  )
                  temp %= MOD
  
              ans = temp % MOD
  
          answers.append(ans)
          print(ans)
  
  for ans in answers[-2::-1]:
      print(ans)
  
problem_description: Statement
  
  Takahashi throws N dice, each having K sides with all integers from 1 to K.
  The dice are NOT pairwise distinguishable. For each i=2,3,...,2K, find the
  following value modulo 998244353:
  
    * The number of combinations of N sides shown by the dice such that the sum of no two different sides is i.
  
  Note that the dice are NOT distinguishable, that is, two combinations are
  considered different when there exists an integer k such that the number of
  dice showing k is different in those two.
samples: [{"input": "3 3", "output": "7\n    7\n    4\n    7\n    7\n    \n\n  * For i=2, the combinations (1,2,2),(1,2,3),(1,3,3),(2,2,2),(2,2,3),(2,3,3),(3,3,3) satisfy the condition, so the answer is 7.\n  * For i=3, the combinations (1,1,1),(1,1,3),(1,3,3),(2,2,2),(2,2,3),(2,3,3),(3,3,3) satisfy the condition, so the answer is 7.\n  * For i=4, the combinations (1,1,1),(1,1,2),(2,3,3),(3,3,3) satisfy the condition, so the answer is 4.\n\n* * *"}, {"input": "4 5", "output": "36\n    36\n    20\n    20\n    20\n    36\n    36\n    \n\n* * *"}, {"input": "6 1000", "output": "149393349\n    149393349\n    668669001\n    668669001\n    4000002\n    4000002\n    4000002\n    668669001\n    668669001\n    149393349\n    149393349"}]