#include<stdio.h>
#include<algorithm>
#include<vector>
#include<chrono>
#include<random>
#include<tuple>
typedef unsigned int uint;
typedef unsigned long long ull;
constexpr uint mod{998244353};
constexpr uint plus(const uint &x,const uint &y) {
    if(x+y>=mod) {
        return x+y-mod;
    }
    return x+y;
}
constexpr uint minus(const uint &x,const uint &y) {
    if(x<y) {
        return x-y+mod;
    }
    return x-y;
}
constexpr uint power(uint x,uint y) {
    uint s(1);
    while(y>0) {
        if(y&1) {
            s=ull(s)*x%mod;
        }
        x=ull(x)*x%mod;
        y>>=1;
    }
    return s;
}
std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());
template<typename Tp>
inline Tp rand(const Tp &l,const Tp &r) {
    return std::uniform_int_distribution<Tp>(l,r)(rng);
}
inline void FWT_or(const uint &n,uint *const f) {
    for(uint l=1;l!=n;l<<=1) {
        for(uint *i=f;i!=f+n;i+=l<<1) {
            for(uint *j=i;j!=i+l;j++) {
                *(j+l)=plus(*(j+l),*j);
            }
        }
    }
}
inline void IFWT_or(const uint &n,uint *const f) {
    for(uint l=1;l!=n;l<<=1) {
        for(uint *i=f;i!=f+n;i+=l<<1) {
            for(uint *j=i;j!=i+l;j++) {
                *(j+l)=minus(*(j+l),*j);
            }
        }
    }
}
inline void FWT_and(const uint &n,uint *const f) {
    for(uint l=1;l!=n;l<<=1) {
        for(uint *i=f;i!=f+n;i+=l<<1) {
            for(uint *j=i;j!=i+l;j++) {
                *j=plus(*j,*(j+l));
            }
        }
    }
}
inline void IFWT_and(const uint &n,uint *const f) {
    for(uint l=1;l!=n;l<<=1) {
        for(uint *i=f;i!=f+n;i+=l<<1) {
            for(uint *j=i;j!=i+l;j++) {
                *j=minus(*j,*(j+l));
            }
        }
    }
}
inline uint BM(const uint &n,const uint *const f,uint *const g) {
    uint lst[n+1]{},tmp[n+1]{};
    uint len(0);
    uint lstpos(-1),lstlen(0);
    uint lstdel(0);
    for(uint i=0;i!=n;i++) {
        uint val(0);
        for(uint j=1;j<=len;j++) {
            val=(val+ull(f[i-j])*g[j])%mod;
        }
        if(val==f[i]) {
            continue;
        }
        if(lstpos==-1) {
            len=i+1;
            std::fill(g+1,g+i+2,0);
            lstpos=i,lstlen=0;
            lstdel=f[i];
            continue;
        }
        const uint del(minus(f[i],val));
        const uint coef(ull(del)*power(lstdel,mod-2)%mod);
        std::copy(g+1,g+len+1,tmp+1);
        for(uint j=1;j<=lstlen;j++) {
            g[j+(i-lstpos)]=(g[j+(i-lstpos)]+ull(mod-coef)*lst[j])%mod;
        }
        g[i-lstpos]=plus(g[i-lstpos],coef);
        std::tie(lstlen,len)=std::make_tuple(len,std::max(len,lstlen+(i-lstpos)));
        lstpos=i,lstdel=del;
        std::copy(tmp+1,tmp+lstlen+1,lst+1);
    }
    return len;
}
constexpr uint N{8};
uint w[1<<N|1];
constexpr uint getn(const uint &n) {
    return 1<<std::__lg(n-1)+1;
}
inline void init() {
    w[1<<N]=power(3,mod-1>>N+2);
    for(int i=N;i!=0;i--) {
        w[1<<i-1]=ull(w[1<<i])*w[1<<i]%mod;
    }
    w[0]=1;
    for(int i=1;i!=1<<N;i++) {
        w[i]=ull(w[i&i-1])*w[i&-i]%mod;
    }
}
inline void DIF(const uint &n,uint *const f) {
    for(uint l=n>>1;l!=0;l>>=1) {
        for(uint *i=f,*o=w;i!=f+n;i+=l<<1,o++) {
            for(uint *j=i;j!=i+l;j++) {
                const uint t(ull(*(j+l))**o%mod);
                *(j+l)=minus(*j,t),*j=plus(*j,t);
            }
        }
    }
}
inline void DIT(const uint &n,uint *const f) {
    for(uint l=1;l!=n;l<<=1) {
        for(uint *i=f,*o=w;i!=f+n;i+=l<<1,o++) {
            for(uint *j=i;j!=i+l;j++) {
                const uint t(*(j+l));
                *(j+l)=ull(*j+mod-t)**o%mod,*j=plus(*j,t);
            }
        }
    }
    std::reverse(f+1,f+n);
    const uint t(mod-(mod-1>>std::__lg(n)));
    for(uint *i=f;i!=f+n;i++) {
        *i=ull(*i)*t%mod;
    }
}
inline void multiply(const uint &n,uint *const f,uint *const g) {
    DIF(n,f),DIF(n,g);
    for(uint i=0;i!=n;i++) {
        f[i]=ull(f[i])*g[i]%mod;
    }
    DIT(n,f);
}
inline void multiply(const uint &n,const uint *const f,const uint *const g,uint *const h) {
    uint *t(new uint[n]{});
    std::copy(f,f+n,h);
    std::copy(g,g+n,t);
    multiply(n,h,t);
    delete[] t;
}
inline void inverse(const uint &n,const uint *const f,uint *const g) {
    uint *t0(new uint[n<<1]{}),*t1(new uint[n<<1]{});
    t1[0]=power(f[0],mod-2);
    for(uint l=1;l!=n;l<<=1) {
        std::copy(f,f+(l<<1),t0);
        std::fill(t0+(l<<1),t0+(l<<2),0);
        DIF(l<<2,t0),DIF(l<<2,t1);
        for(uint i=0;i!=l<<2;i++) {
            t1[i]=(2+ull(mod-t0[i])*t1[i])%mod*t1[i]%mod;
        }
        DIT(l<<2,t1);
        std::fill(t1+(l<<1),t1+(l<<2),0);
    }
    std::copy(t1,t1+n,g);
    delete[] t0,delete[] t1;
}
inline void add(const std::vector<uint> &f,std::vector<uint> &g) {
    if(g.size()<f.size()) {
        g.resize(f.size());
    }
    for(uint i=0;i!=f.size();i++) {
        g[i]=plus(g[i],f[i]);
    }
}
inline void sub(const std::vector<uint> &f,std::vector<uint> &g) {
    if(g.size()<f.size()) {
        g.resize(f.size());
    }
    for(uint i=0;i!=f.size();i++) {
        g[i]=minus(g[i],f[i]);
    }
}
inline void multiply(const std::vector<uint> &f,const std::vector<uint> &g,std::vector<uint> &h) {
    const uint n(f.size()),m(g.size());
    if(n==0||m==0) {
        return h.clear(),void();
    }
    const uint k(getn(n+m-1));
    uint *t0(new uint[k]{}),*t1(new uint[k]{});
    std::copy(f.begin(),f.end(),t0);
    std::copy(g.begin(),g.end(),t1);
    multiply(k,t0,t1);
    h.assign(t0,t0+n+m-1);
    delete[] t0,delete[] t1;
}
inline void inverse(const std::vector<uint> &f,std::vector<uint> &g) {
    const uint n(f.size()),k(getn(n));
    uint *t0(new uint[k<<1]{}),*t1(new uint[k<<1]{});
    t1[0]=power(f[0],mod-2);
    for(uint l=1;l!=k;l<<=1) {
        std::copy(f.begin(),f.begin()+std::min(n,l<<1),t0);
        std::fill(t0+std::min(n,l<<1),t0+(l<<2),0);
        DIF(l<<2,t0),DIF(l<<2,t1);
        for(uint i=0;i!=l<<2;i++) {
            t1[i]=(2+ull(mod-t0[i])*t1[i])%mod*t1[i]%mod;
        }
        DIT(l<<2,t1);
        std::fill(t1+(l<<1),t1+(l<<2),0);
    }
    g.assign(t1,t1+n);
    delete[] t0,delete[] t1;
}
inline void divide(const std::vector<uint> &f,const std::vector<uint> &g,std::vector<uint> &h) {
    const uint n(f.size()),m(g.size());
    if(m>n) {
        return h.clear(),void();
    }
    std::vector<uint> t0(f.rbegin(),f.rend()),t1(g.rbegin(),g.rend());
    t1.resize(n-m+1),inverse(t1,t1);
    multiply(t0,t1,h),h.resize(n-m+1);
    std::reverse(h.begin(),h.end());
}
inline void modulo(const std::vector<uint> &f,const std::vector<uint> &g,std::vector<uint> &h) {
    const uint n(f.size()),m(g.size());
    if(n<m) {
        return h=f,void();
    }
    divide(f,g,h);
    multiply(g,h,h);
    h.resize(m-1);
    for(uint i=0;i!=m-1;i++) {
        h[i]=minus(f[i],h[i]);
    }
}
inline void linear_recurrence(const uint &n,const uint *const f,uint *const g,const int &k) {
    std::vector<uint> t0,t1,t2,t3;
    t0.assign({0,1});
    t1.assign({1});
    t2.assign(f,f+n+1);
    for(int i=k;i;i>>=1) {
        if(i&1) {
            multiply(t1,t0,t3);
            modulo(t3,t2,t1);
        }
        multiply(t0,t0,t3);
        modulo(t3,t2,t0);
    }
    std::fill(g,g+n,0);
    std::copy(t1.begin(),t1.end(),g);
}
uint wt[1<<17|1],coef[1<<17|1];
uint val[2][1<<17|1];
uint f[85][2][1<<17|1],g[2][1<<17|1],h[2][1<<17|1];
uint arr[85],arr1[85],arr2[85],arr3[85];
uint ans[1<<17|1];
int main() {
    init();
    int n,k,x;uint p;
    scanf("%d%u%d%d",&n,&p,&k,&x);
    for(int i=0;i!=1<<n;i++) {
        scanf("%u",wt+i);
    }
    const uint p2(power(2,mod-1-n));
    for(int i=0;i!=1<<n;i++) {
        val[0][i]=ull(p2)*p%mod;
    }
    FWT_or(1<<n,val[0]);
    for(int i=0;i!=1<<n;i++) {
        val[1][i]=ull(p2)*(mod+1-p)%mod;
    }
    FWT_and(1<<n,val[1]);
    for(int i=0;i!=1<<n;i++) {
        coef[i]=rand<uint>(1,mod-1);
    }
    std::fill(f[0][0],f[0][0]+(1<<n),0);
    std::fill(f[0][1],f[0][1]+(1<<n),0);
    f[0][0][x]=1;
    for(int i=1;i<=80;i++) {
        std::copy(f[i-1][0],f[i-1][0]+(1<<n),g[0]),FWT_or(1<<n,g[0]);
        std::copy(f[i-1][1],f[i-1][1]+(1<<n),g[1]),FWT_or(1<<n,g[1]);
        for(int j=0;j!=1<<n;j++) {
            g[0][j]=ull(g[0][j])*val[0][j]%mod;
            g[1][j]=ull(g[1][j])*val[0][j]%mod;
        }
        IFWT_or(1<<n,g[0]);
        IFWT_or(1<<n,g[1]);
        std::copy(g[0],g[0]+(1<<n),h[0]);
        std::copy(g[1],g[1]+(1<<n),h[1]);
        std::copy(f[i-1][0],f[i-1][0]+(1<<n),g[0]),FWT_and(1<<n,g[0]);
        std::copy(f[i-1][1],f[i-1][1]+(1<<n),g[1]),FWT_and(1<<n,g[1]);
        for(int j=0;j!=1<<n;j++) {
            g[0][j]=ull(g[0][j])*val[1][j]%mod;
            g[1][j]=ull(g[1][j])*val[1][j]%mod;
        }
        IFWT_and(1<<n,g[0]);
        IFWT_and(1<<n,g[1]);
        for(int j=0;j!=1<<n;j++) {
            h[0][j]=plus(h[0][j],g[0][j]);
            h[1][j]=plus(h[1][j],g[1][j]);
            h[1][j]=(h[1][j]+ull(h[0][j])*wt[j])%mod;
        }
        std::copy(h[0],h[0]+(1<<n),f[i][0]);
        std::copy(h[1],h[1]+(1<<n),f[i][1]);
        for(int j=0;j!=1<<n;j++) {
            arr[i]=(arr[i]+ull(f[i][1][j])*coef[j])%mod;
        }
        if(i==k) {
            for(int j=0;j!=1<<n;j++) {
                printf("%u%c",f[i][1][j],j+1==1<<n?'\n':' ');
            }
            return 0;
        }
    }
    arr[0]=0;
    const int len(BM(81,arr,arr1));
    for(int i=1;i<=len;i++) {
        arr2[len-i]=minus(0,arr1[i]);
    }
    arr2[len]=1;
    linear_recurrence(len,arr2,arr3,k);
    std::fill(ans,ans+(1<<n),0);
    for(int i=0;i<len;i++) {
        for(int j=0;j!=1<<n;j++) {
            ans[j]=(ans[j]+ull(f[i][1][j])*arr3[i])%mod;
        }
    }
    for(int j=0;j!=1<<n;j++) {
        printf("%u%c",ans[j],j+1==1<<n?'\n':' ');
    }
    return 0;
}