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: import sys
  
  readline = sys.stdin.readline
  
  MOD = 998244353
  
  
  def frac(limit):
      frac = [1] * limit
      for i in range(2, limit):
          frac[i] = i * frac[i - 1] % MOD
      fraci = [None] * limit
      fraci[-1] = pow(frac[-1], MOD - 2, MOD)
      for i in range(-2, -limit - 1, -1):
          fraci[i] = fraci[i + 1] * (limit + i + 1) % MOD
      return frac, fraci
  
  
  frac, fraci = frac(1341398)
  
  
  class NTT:
      def __init__(self, MOD=998244353, pr=3, LS=20):
          self.MOD = MOD
          self.N0 = 1 << LS
          omega = pow(pr, (MOD - 1) // self.N0, MOD)
          omegainv = pow(omega, MOD - 2, MOD)
          self.w = [0] * (self.N0 // 2)
          self.winv = [0] * (self.N0 // 2)
          self.w[0] = 1
          self.winv[0] = 1
          for i in range(1, self.N0 // 2):
              self.w[i] = (self.w[i - 1] * omega) % MOD
              self.winv[i] = (self.winv[i - 1] * omegainv) % MOD
          used = set()
          for i in range(self.N0 // 2):
              if i in used:
                  continue
              j = 0
              for k in range(LS - 1):
                  j |= (i >> k & 1) << (LS - 2 - k)
              used.add(j)
              self.w[i], self.w[j] = self.w[j], self.w[i]
              self.winv[i], self.winv[j] = self.winv[j], self.winv[i]
  
      def _fft(self, A):
          MOD = self.MOD
          M = len(A)
          bn = 1
          hbs = M >> 1
          while hbs:
              for j in range(hbs):
                  A[j], A[j + hbs] = A[j] + A[j + hbs], A[j] - A[j + hbs]
                  if A[j] > MOD:
                      A[j] -= MOD
                  if A[j + hbs] < 0:
                      A[j + hbs] += MOD
              for bi in range(1, bn):
                  wi = self.w[bi]
                  for j in range(bi * hbs * 2, bi * hbs * 2 + hbs):
                      A[j], A[j + hbs] = (A[j] + wi * A[j + hbs]) % MOD, (
                          A[j] - wi * A[j + hbs]
                      ) % MOD
              bn <<= 1
              hbs >>= 1
  
      def _ifft(self, A):
          MOD = self.MOD
          M = len(A)
          bn = M >> 1
          hbs = 1
          while bn:
              for j in range(hbs):
                  A[j], A[j + hbs] = A[j] + A[j + hbs], A[j] - A[j + hbs]
                  if A[j] > MOD:
                      A[j] -= MOD
                  if A[j + hbs] < 0:
                      A[j + hbs] += MOD
              for bi in range(1, bn):
                  winvi = self.winv[bi]
                  for j in range(bi * hbs * 2, bi * hbs * 2 + hbs):
                      A[j], A[j + hbs] = (A[j] + A[j + hbs]) % MOD, winvi * (
                          A[j] - A[j + hbs]
                      ) % MOD
              bn >>= 1
              hbs <<= 1
  
      def convolve(self, A, B):
          LA = len(A)
          LB = len(B)
          LC = LA + LB - 1
          M = 1 << (LC - 1).bit_length()
          A += [0] * (M - LA)
          B += [0] * (M - LB)
          self._fft(A)
          self._fft(B)
          C = [0] * M
          for i in range(M):
              C[i] = A[i] * B[i] % self.MOD
          self._ifft(C)
          minv = pow(M, self.MOD - 2, self.MOD)
          for i in range(LC):
              C[i] = C[i] * minv % self.MOD
          return C[:LC]
  
          return C
  
      def inverse(self, A):
          LA = len(A)
          dep = (LA - 1).bit_length()
          M = 1 << dep
          A += [0] * (M - LA)
  
          g = [pow(A[0], self.MOD - 2, self.MOD)]
          for n in range(dep):
              dl = 1 << (n + 1)
              f = A[:dl]
              fg = self.convolve(f, g[:])[:dl]
              fgg = self.convolve(fg, g[:])[:dl]
              ng = [None] * dl
              for i in range(dl // 2):
                  ng[i] = (2 * g[i] - fgg[i]) % self.MOD
              for i in range(dl // 2, dl):
                  ng[i] = self.MOD - fgg[i]
              g = ng[:]
          return g[:LA]
  
      def integral(self, A):
          A = [1] + [A[i] * fraci[i + 2] % self.MOD for i in range(len(A))]
  
  
  N, M = map(int, readline().split())
  A = list(map(int, readline().split()))
  B = list(map(int, readline().split()))
  T = NTT()
  print(*T.convolve(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"}]