#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using base = complex<double>;
const int N = 4e6 ;
const int prime=998244353, _w = 3,inv_w=332748118, inv2 = (prime + 1) / 2;
const double PI = acos(-1);
vector<long long>emp;
long long power(long long a,long long b){// a^b % p
    long long ans=1;
    while(b>0){
        if(b&1)// b is odd
            ans=ans*a%prime;
        a=a*a%prime;
        b/=2;
    }
    return ans;
}
struct polynomial{
    vector<long long>coefficient,point_value;
    polynomial(){
        coefficient.clear();
        point_value.clear();
    }
    polynomial(vector<long long>a,vector<long long>b){
        coefficient=a,point_value=b;
    }
    long long size(){
        return coefficient.size();
    }
    void resize(long long sz){
        coefficient.resize(sz);
        point_value.resize(sz);
    }
    polynomial newton(long long n){
        polynomial invQk,invQkplus1,two;
        invQk.resize(1);
        two.resize(1);
        two.coefficient[0]=2;
        invQk.coefficient[0]=power(coefficient[0],prime-2);
        int k=0;
        if(n==1){
            return invQk;
        }
        while((1ll<<k)<n){
            invQkplus1=invQk*(two-*this*(invQk));
            while(invQkplus1.size()>(1ll<<(k+1)))
                invQkplus1.coefficient.pop_back();
            k++;
            invQk=invQkplus1;
        }
        while(invQk.size()>n)
            invQk.coefficient.pop_back();
        return invQk;
    }
    void fft(long long sz){
        vector<long long> evaluation(sz);
        long long i = 0;
        for (int i = 0 ; i < sz; ++i) 
            evaluation[i] = i < int(coefficient.size()) ? coefficient[i]: 0;//zero pedding
        for (int j = 1; j < sz-1; ++j) {
            for (int k = sz >> 1; k > (i ^= k); k >>= 1);
                if (j < i)
                    swap(evaluation[i], evaluation[j]);
        }
        for (int i = 2; i <= sz; i *= 2) {
            const long long wi = power(_w,  (prime - 1) / i); //
            for (int j = 0; j < sz; j += i) {
                long long w=1;
                for (int k = j, mid = i / 2; k < j + mid; k++) {
                    auto t = w*evaluation[k + mid]%prime, u = evaluation[k];
                    evaluation[k] =(u+t)%prime;
                    evaluation[k + mid] =(u-t+prime)%prime;
                    w=w*wi%prime;
                }
            }
        }
        point_value=evaluation;
    }
    void ifft(long long sz){
        vector<long long> evaluation(sz);
        for (int i = 0 ; i < sz; ++i) 
            evaluation[i] = i < int(point_value.size()) ? point_value[i]: 0;//zero pedding
        long long i = 0;
        for (int j = 1; j < sz-1; ++j) {
            for (int k = sz >> 1; k > (i ^= k); k >>= 1);
                if (j < i)
                    swap(evaluation[i], evaluation[j]);
        }
        for (int i = 2; i <= sz; i *= 2) {
            const long long wi = power(inv_w,  (prime - 1) / i); //
            for (int j = 0; j < sz; j += i) {
                long long w=1;
                for (int k = j, mid = i / 2; k < j + mid; k++) {
                    auto t = w*evaluation[k + mid]%prime, u = evaluation[k];
                    evaluation[k] =(u+t)%prime;
                    evaluation[k + mid] =(u-t+prime)%prime;
                    w=w*wi%prime;
                }
            }
        }
        long long inv=power(sz,prime-2);
        //inv =1;
        for (int i = 0; i < sz; ++i) evaluation[i] = evaluation[i]*inv%prime;
        coefficient.resize(sz);
        coefficient=evaluation;
        return ;
    }
    polynomial rev(){
        polynomial r=*this;
        reverse(r.coefficient.begin(),r.coefficient.end());
        return r;
    }
    friend polynomial operator - (polynomial a, polynomial b) {
		vector<long long> res(max(a.size(), b.size()));
		for(int i=0;i<res.size();i++){
            long long x,y;
            if(i<a.size())
                x=a.coefficient[i];
            else
                x=0;
            if(i<b.size())
                y=b.coefficient[i];
            else
                y=0;
            res[i]=x-y;
        }
		return polynomial(res,emp);
	}
    friend polynomial operator * (polynomial a, polynomial b) {
		if(a.size()==0||b.size()==0) return polynomial();
		int lim, sum = a.size() + b.size() - 1;
		for(lim = 1; lim < sum; lim *= 2);
		a.resize(lim), b.resize(lim);
        a.fft(lim),b.fft(lim);
        vector<long long>z(lim);
        for(int i = 0; i < lim; i++)
            z[i]=a.point_value[i]*b.point_value[i]%prime;
        polynomial c(emp,z);
        c.ifft(lim);
        while(c.size()>sum)
            c.coefficient.pop_back(),c.point_value.pop_back();
        //for(int i=0;i<lim;i++)
        //    cout<<c.point_value[i]<<" ";
		return c;
	}
    friend polynomial operator / (polynomial p, polynomial q) {// return D(x) for P(x)=Q(x)D(x)+R(x)
		polynomial pr=p.rev(),qr=q.rev(),d;
        if(p.size()<q.size()){
            d=polynomial(emp,emp);
            return d; 
        }
        d=pr*qr.newton(p.size()-q.size()+1);
        while(d.size()>p.size()-q.size()+1)
            d.coefficient.pop_back();
        d=d.rev();
		return d;
	}
    friend polynomial operator % (polynomial p, polynomial q){
        polynomial d=p/q,r;
        r=p-q*d;
        while(r.size()>=q.size())
            r.coefficient.pop_back();
        for(int i=0;i<r.size();i++)
            r.coefficient[i]=(r.coefficient[i]+prime)%prime;
        return r;
    }
};
struct node{
    long long leftindex,rightindex; 
    polynomial subproduct,remainder;
    node(){
        leftindex=-1;
        rightindex=-1;
    };
}tree[N];
vector<long long>points,eval;
void buildtree(int id){
    if(tree[id].leftindex==tree[id].rightindex){
        vector<ll>coefficent(2);
        //cout<<id<<" "<<tree[id].leftindex<<" "<<tree[id].rightindex<<endl;
        coefficent[1]=1;
        coefficent[0]=-points[tree[id].leftindex];
        tree[id].subproduct=polynomial(coefficent,emp);
        return ;
    }
    //cout<<id<<" "<<tree[id].leftindex<<" "<<tree[id].rightindex<<endl;
    long long mid_point=(tree[id].leftindex+tree[id].rightindex)/2;
    tree[2*id].leftindex=tree[id].leftindex;
    tree[2*id].rightindex=mid_point;
    buildtree(2*id);
    tree[2*id+1].leftindex=mid_point+1;
    tree[2*id+1].rightindex=tree[id].rightindex;
    buildtree(2*id+1);
    tree[id].subproduct=tree[2*id].subproduct*tree[2*id+1].subproduct;
}
void runtree(polynomial now,int id){
    tree[id].remainder=now%tree[id].subproduct;
    if(tree[id].leftindex==tree[id].rightindex){
        eval[tree[id].leftindex]=tree[id].remainder.coefficient[0];
        return ;
    }
    runtree(tree[id].remainder,2*id);
    runtree(tree[id].remainder,2*id+1);
}
vector<long long> multipoint_evaluation(polynomial f,vector<long long>p){
    vector<long long>evaluation;
    points=p;
    tree[1].leftindex=0,tree[1].rightindex=points.size()-1;
    buildtree(1);
    eval.clear();
    eval.resize(p.size());
    runtree(f,1);
    return eval;
}
int main(){
    long long n,m,x;
    vector<ll>a,points;
    cin>>n>>m;
    for(ll i=0;i<n;i++)
        cin>>x,a.push_back(x);
    for(ll i=0;i<m;i++)
        cin>>x,points.push_back(x);
    //cout<<power(3,prime-2)<<endl;
    polynomial p(a,emp);
    vector<ll> evaluation=multipoint_evaluation(p,points);
    for(auto t:evaluation)
        cout<<t<<endl;
}