output_description: Print the answer in the following format:
  
      
      
      c_0 c_1 ... c_{(N - 1) + (M - 1)}
      
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M
      a_0 a_1 ... a_{N-1}
      b_0 b_1 ... b_{M-1}
attempt: class Ntt:
      def __init__(self, mod=10**9 + 7, root=3):
          self.mod = mod
          self.roots = [pow(root, (mod - 1) >> i, mod) for i in range(24)]
          self.iroots = [pow(x, mod - 2, mod) for x in self.roots]
  
      def untt(self, a, n):
          for i in range(n):
              m = 1 << (n - i - 1)
              for s in range(1 << i):
                  wn = 1
                  s *= m * 2
                  for p in range(m):
                      a[s + p], a[s + p + m] = (a[s + p] + a[s + p + m]) % self.mod, (
                          a[s + p] - a[s + p + m]
                      ) * wn % self.mod
                      wn = wn * self.roots[n - i] % self.mod
  
      def iuntt(self, a, n):
          for i in range(n):
              m = 1 << i
              for s in range(1 << (n - i - 1)):
                  wn = 1
                  s *= m * 2
                  for p in range(m):
                      a[s + p], a[s + p + m] = (
                          a[s + p] + a[s + p + m] * wn
                      ) % self.mod, (a[s + p] - a[s + p + m] * wn) % self.mod
                      wn = wn * self.iroots[i + 1] % self.mod
  
          inv = pow((self.mod + 1) // 2, n, self.mod)
          for i in range(1 << n):
              a[i] = a[i] * inv % self.mod
  
      def convolution(self, a, b):
          deg = len(a) + len(b) - 2
          n = deg.bit_length()
          N = 1 << n
          a += [0] * (N - len(a))
          b += [0] * (N - len(b))
          self.untt(a, n)
          self.untt(b, n)
          for i in range(N):
              a[i] = a[i] * b[i] % self.mod
          self.iuntt(a, n)
          return a[: deg + 1]
  
  
  N, M = map(int, input().split())
  a = list(map(int, input().split()))
  b = list(map(int, input().split()))
  mod = 998244353
  
  ntt = Ntt(mod=mod)
  print(*ntt.convolution(a, b))
  
problem_description: Statement
  
  You are given two integer arrays a_0, a_1, ..., a_{N - 1} and b_0, b_1, ...,
  b_{M - 1}. Calculate the array c_0, c_1, ..., c_{(N - 1) + (M - 1)}, defined
  by c_i = \sum_{j = 0}^i a_j b_{i - j} \bmod 998244353.
samples: [{"input": "4 5\n    1 2 3 4\n    5 6 7 8 9", "output": "5 16 34 60 70 70 59 36\n    \n\n* * *"}, {"input": "1 1\n    10000000\n    10000000", "output": "871938225"}]