class Polynominal_Error(Exception):
    pass

class Polynominal():
    def __init__(self,P=[],C="X"):
        U=[]
        for (c,k) in P:
            if c!=0:
                U.append((c,k))
        
        if U==[]:
            U=[(0,0)]
            
        self.P=U
        self.C=C
        
        self.deg=max(U,key=lambda x:x[1])[1]

    def __str__(self):
        S=""
        for (c,k) in self.P:
            if k!=0 and k!=1:
                S+="+{} {}^{}".format(c,self.C,k)
            elif k==1:
                S+="+{} {}".format(c,self.C)
            else:
                S+="+{}".format(c)

        return S[1:]

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return self.scale(-1)

    #加法
    def __add__(self,other):
        if isinstance(other,Polynominal):
            P=self.P
            Q=other.P

            D={k:c for (c,k) in Q}
            for (c,k) in P:
                if k in D:
                    D[k]+=c
                else:
                    D[k]=c

            E=[]
            for k in D:
                E.append((D[k],k))
            
            return Polynominal(E,self.C)
        else:
            return self+Polynominal([(other,0)],self.C)

    def __radd__(self,other):
        return self+Polynominal([(other,0)],self.C)

    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        return -self+other

    #X^mを掛ける
    def mini_mul(self,m):
        P=[]
        for (k,c) in self.P:
            P.append((k,c+m))

        return Polynominal(P)
    
    #乗法
    def __mul__(self,other):
        if isinstance(other,Polynominal):
            P=self.P
            Q=other.P
            
            S=Polynominal()
            for (c,m) in Q:
                S=S+(self.mini_mul(m)).scale(c)

            return S
        else:
            return self.scale(other)

    def __rmul__(self,other):
        return self.scale(other)

    #累乗
    def __pow__(P,n):
        if n<0:
            raise  Polynominal_Error("nが負です.")

        R=Polynominal([(1,0)])
        D=P
        
        while n>0:
            if n%2==1:
                R*=D
            D*=D
            n=n>>1
                
        return R
    
    #スカラー倍
    def scale(self,s):
        Q=[]
        for (c,k) in self.P:
            Q.append((c*s,k))

        return Polynominal(Q,self.C)

    #代入
    def substitute(self,a):
        P=self.P
        P.sort(key=lambda x:x[1])

        D={k:c for (c,k) in P}
        
        if P[0][1]>=0:
            S=0
            t=1
            for i in range(self.deg+1):
                if i in D:
                    S+=D[i]*t
                t*=a
                
        return S                

def Poly(*P):
    Q=[]

    for i in range(len(P)):
        Q.append((P[i],i))

    return Polynominal(Q)

def Coefficient_Dictionary(P):
    K=P.P

    D={}
    for (c,k) in K:
        D[k]=c

    return D

def Coefficient(P,k):
    D=Coefficient_Dictionary(P)
    if k in D:
        return D[k]
    else:
        return 0

class Modulo_Error(Exception):
    pass

class Modulo():
    def __init__(self,a,n):
        self.a=a%n
        self.n=n

    def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
    def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

    def __neq__(self,other):
        return not(self==other)
    
    #加法
    def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

    def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
    def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
    def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
    def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
    def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()
        
def Poly(*P):
    Q=[]

    for i in range(len(P)):
        Q.append((P[i],i))

    return Polynominal(Q)

def Coefficient_Dictionary(P):
    K=P.P

    D={}
    for (c,k) in K:
        D[k]=c

    return D
#--------------------------------------
N,Q=map(int,input().split())
A=list(map(int,input().split()))
B=list(map(int,input().split()))
M=998244353

P=Poly(Modulo(1,M))
for a in A:
    P=P*Poly(Modulo(a-1,M),1)

D=Coefficient_Dictionary(P)
for b in B:
    if b in D:
        print(D[b].a)
    else:
        print(0)