import sys
input = sys.stdin.readline

def main():
    mod=998244353
    
    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]



    
    N,M=map(int, input().split())
    A=list(map(int, input().split()))
    B=list(map(int, input().split()))
    
    ntt=NTT()
    C=ntt.convolve(A,B)
    ans=[]
    
    for c in C:
        ans.append(c)
        
    print(' '.join(map(str, C)))
    

main()


Measured memory_bytes: 276024