// BEGIN: main.cpp
#line 1 "main.cpp"
#include<bits/stdc++.h>
using namespace std;

#define all(a) a.begin(),a.end()
#define pb push_back
#define sz(a) ((int)a.size())

using ll=long long;
using u32=unsigned int;
using u64=unsigned long long;
using i128=__int128;
using u128=unsigned __int128;
using f128=__float128;

using pii=pair<int,int>;
using pll=pair<ll,ll>;

template<typename T> using vc=vector<T>;
template<typename T> using vvc=vc<vc<T>>;
template<typename T> using vvvc=vc<vvc<T>>;

using vi=vc<int>;
using vll=vc<ll>;
using vvi=vc<vi>;
using vvll=vc<vll>;

#define vv(type,name,n,...) \
    vector<vector<type>> name(n,vector<type>(__VA_ARGS__))
#define vvv(type,name,n,m,...) \
    vector<vector<vector<type>>> name(n,vector<vector<type>>(m,vector<type>(__VA_ARGS__)))

template<typename T> using min_heap=priority_queue<T,vector<T>,greater<T>>;
template<typename T> using max_heap=priority_queue<T>;

// https://trap.jp/post/1224/
#define rep1(n) for(ll i=0; i<(ll)(n); ++i)
#define rep2(i,n) for(ll i=0; i<(ll)(n); ++i)
#define rep3(i,a,b) for(ll i=(ll)(a); i<(ll)(b); ++i)
#define rep4(i,a,b,c) for(ll i=(ll)(a); i<(ll)(b); i+=(c))
#define cut4(a,b,c,d,e,...) e
#define rep(...) cut4(__VA_ARGS__,rep4,rep3,rep2,rep1)(__VA_ARGS__)
#define per1(n) for(ll i=((ll)n)-1; i>=0; --i)
#define per2(i,n) for(ll i=((ll)n)-1; i>=0; --i)
#define per3(i,a,b) for(ll i=((ll)a)-1; i>=(ll)(b); --i)
#define per4(i,a,b,c) for(ll i=((ll)a)-1; i>=(ll)(b); i-=(c))
#define per(...) cut4(__VA_ARGS__,per4,per3,per2,per1)(__VA_ARGS__)
#define rep_subset(i,s) for(ll i=(s); i>=0; i=(i==0?-1:(i-1)&(s)))

template<typename T, typename S> constexpr T ifloor(const T a, const S b){return a/b-(a%b&&(a^b)<0);}
template<typename T, typename S> constexpr T iceil(const T a, const S b){return ifloor(a+b-1,b);}

template<typename T>
void sort_unique(vector<T> &vec){
    sort(vec.begin(),vec.end());
    vec.resize(unique(vec.begin(),vec.end())-vec.begin());
}

template<typename T, typename S> constexpr bool chmin(T &a, const S b){if(a>b) return a=b,true; return false;}
template<typename T, typename S> constexpr bool chmax(T &a, const S b){if(a<b) return a=b,true; return false;}

template<typename T, typename S> istream& operator >> (istream& i, pair<T,S> &p){return i >> p.first >> p.second;}
template<typename T, typename S> ostream& operator << (ostream& o, const pair<T,S> &p){return o << p.first << ' ' << p.second;}

#ifdef i_am_noob
#define bug(...) cerr << "#" << __LINE__ << ' ' << #__VA_ARGS__ << "- ", _do(__VA_ARGS__)
template<typename T> void _do(vector<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(unordered_set<T> x){for(auto i: x) cerr << i << ' ';cerr << "\n";}
template<typename T> void _do(T && x) {cerr << x << endl;}
template<typename T, typename ...S> void _do(T && x, S&&...y) {cerr << x << ", "; _do(y...);}
#else
#define bug(...) 777771449
#endif

template<typename T> void print(vector<T> x){for(auto i: x) cout << i << ' ';cout << "\n";}
template<typename T> void print(set<T> x){for(auto i: x) cout << i << ' ';cout << "\n";}
template<typename T> void print(unordered_set<T> x){for(auto i: x) cout << i << ' ';cout << "\n";}
template<typename T> void print(T && x) {cout << x << "\n";}
template<typename T, typename... S> void print(T && x, S&&... y) {cout << x << ' ';print(y...);}

template<typename T> istream& operator >> (istream& i, vector<T> &vec){for(auto &x: vec) i >> x; return i;}

vvi read_graph(int n, int m, int base=1){
    vvi adj(n);
    for(int i=0,u,v; i<m; ++i){
        cin >> u >> v,u-=base,v-=base;
        adj[u].pb(v),adj[v].pb(u);
    }
    return adj;
}

vvi read_tree(int n, int base=1){return read_graph(n,n-1,base);}

template<typename T, typename S> pair<T,S> operator + (const pair<T,S> &a, const pair<T,S> &b){return {a.first+b.first,a.second+b.second};}

template<typename T> constexpr T inf=0;
template<> constexpr int inf<int> = 0x3f3f3f3f;
template<> constexpr ll inf<ll> = 0x3f3f3f3f3f3f3f3f;

template<typename T> vector<T> operator += (vector<T> &a, int val){for(auto &i: a) i+=val; return a;}

template<typename T> T isqrt(const T &x){T y=sqrt(x+2); while(y*y>x) y--; return y;}

#define ykh mt19937 rng(chrono::steady_clock::now().time_since_epoch().count())

//#include<atcoder/all>
//using namespace atcoder;

//using mint=modint998244353;
//using mint=modint1000000007;

// BEGIN: library/mod/montgomery_modint.hpp
#line 1 "library/mod/montgomery_modint.hpp"

// BEGIN: library/nt/extgcd.hpp
#line 1 "library/nt/extgcd.hpp"

// ax + by = gcd(a,b), {gcd(a,b),x,y}
template<typename T>
array<T,3> extgcd(T a, T b){
    T x1=1,y1=0,x2=0,y2=1;
    while(b!=0){
        T q=a/b;
        a%=b;
        swap(a,b);
        T x3=x1-x2*q,y3=y1-y2*q;
        x1=x2,y1=y2,x2=x3,y2=y3;
    }
    return {a,x1,y1};
}

template<typename T>
T modinv(T x, T m){
    auto [g,val1,val2]=extgcd<T>(x,m);
    assert(g==1);
    if(val1<0) val1+=m;
    return val1;
}// END: library/nt/extgcd.hpp
#line 4 "library/mod/montgomery_modint.hpp"

// arbitrary modint, odd mod
// stores x*(2^K) mod m
// https://judge.yosupo.jp/problem/binomial_coefficient_prime_mod
// https://judge.yosupo.jp/problem/primality_test (used by miller rabin)
template<int id, bool is_prime, int K, typename word, typename dword, typename signed_word> // support multiple modulos at the same time
struct montgomery_modint{
    using mint=montgomery_modint;

    inline static word m,r,val64,m2; // m = modulo < 2^(K-2), r = (-m^(-1)) (mod 2^K), val64 = (2^(2K)) (mod m), m2 = 2m

    static void set_mod(word _m){
        assert((_m&1)&&_m<(word(1)<<(K-2)));
        m=_m,r=m,val64=(-dword(m))%m,m2=m*2;
        // use Newton's method to calculate p^(-1) (mod 2^K)
        // starts from p = p^(-1) (mod 4)
        for(int i=0; i<5; ++i) r*=2-m*r;
        r=-r;
        assert(r*m==word(-1));
    }
    static int get_mod(){
        return m;
    }

    word x;

    montgomery_modint():x(0){}
    montgomery_modint(int64_t _x):x(reduce(dword((_x%m+m)%m)*val64)){}

    word reduce(const dword &y) const {
        // (y + (yr mod 2^K)*p) / (2^K)
        // 0 <= return < 2p
        return (y+dword(word(y)*r)*m)>>K;
    }

    mint operator += (const mint &o){
        x+=o.x;
        if(x>=m2) x-=m2;
        return *this;
    }
    mint operator -= (const mint &o){
        x-=o.x;
        if(int32_t(x)<0) x+=m2;
        return *this;
    }
    mint operator *= (const mint &o){
        x=reduce(dword(x)*o.x);
        return *this;
    }
    mint operator /= (const mint &o){
        return (*this)*=o.inv();
    }
    mint operator + (const mint &o) const {return mint(*this)+=o;}
    mint operator - (const mint &o) const {return mint(*this)-=o;}
    mint operator * (const mint &o) const {return mint(*this)*=o;}
    mint operator / (const mint &o) const {return mint(*this)/=o;}
    mint operator - () const {return mint(0)-*this;}
    mint pow(int64_t n) const {
        assert(n>=0);
        mint res=1,b=*this;
        for(; n; n>>=1,b*=b) if(n&1) res*=b;
        return res;
    }
    inline mint inv1() const {
        return pow(m-2);
    }
    inline mint inv2() const {
        auto [g,val1,val2]=extgcd<signed_word>(get(),m);
        assert(g==1);
        return mint(val1);
    }
    mint inv() const {
        if(is_prime) return inv1();
        return inv2();
    }

    bool operator == (const mint &o) const {
        return (x>=m?x-m:x)==(o.x>=m?o.x-m:o.x);
    }
    bool operator != (const mint &o) const {
        return (x>=m?x-m:x)!=(o.x>=m?o.x-m:o.x);
    }

    word get() const {
        word res=reduce(x);
        return res>=m?res-m:res;
    }

    friend istream& operator >> (istream& is, mint &b){
        int64_t y;
        is >> y;
        b=mint(y);
        return is;
    }
    friend ostream& operator << (ostream& os, const mint &b){
        return os << b.get();
    }

    static constexpr pair<int,int> ntt_data(){
        return {-1,-1};
    }
};

template<int id, bool is_prime> using montgomery_modint_32=montgomery_modint<id,is_prime,32,uint32_t,uint64_t,int32_t>;
template<int id, bool is_prime> using montgomery_modint_64=montgomery_modint<id,is_prime,64,uint64_t,unsigned __int128,int64_t>;// END: library/mod/montgomery_modint.hpp
#line 113 "main.cpp"
// BEGIN: library/mod/modint_basic.hpp
#line 1 "library/mod/modint_basic.hpp"

template<typename mint>
mint fac(int n){
    static const int mod=mint::get_mod();
    static vector<mint> res={1,1};
    if(n>=mod) return 0;
    assert(n>=0);
    while(n>=(int)res.size()) res.push_back(res.back()*res.size());
    return res[n];
}

template<typename mint>
mint inv(int n){
    static const int mod=mint::get_mod();
    static vector<mint> res={0,1};
    assert(n>=0&&n<mod);
    while(n>=(int)res.size()) res.push_back(res[mod%res.size()]*(mod-mod/res.size()));
    return res[n];
}

template<typename mint>
mint ifac(int n){
    static const int mod=mint::get_mod();
    static vector<mint> res={1,1};
    if(n>=mod) return 0;
    assert(n>=0);
    while(n>=(int)res.size()) res.push_back(res.back()*inv<mint>(res.size()));
    return res[n];
}

template<typename mint>
mint C(int n, int m){
    if(m<0||m>n) return 0;
    return fac<mint>(n)*ifac<mint>(m)*ifac<mint>(n-m);
}

template<typename mint>
mint stars_and_bars(int n, int m){
    if(n<0||m<0) return 0;
    if(n==0){
        if(m==0) return 1;
        return 0;
    }
    return C<mint>(m+n-1,n-1);
}// END: library/mod/modint_basic.hpp
#line 114 "main.cpp"
// BEGIN: library/poly/poly.hpp
#line 1 "library/poly/poly.hpp"

#line 4 "library/poly/poly.hpp"
// BEGIN: library/poly/convolution.hpp
#line 1 "library/poly/convolution.hpp"

// BEGIN: library/poly/ntt.hpp
#line 1 "library/poly/ntt.hpp"

template<typename mint>
struct NTT{
    static constexpr int m=mint::get_mod(),N=mint::ntt_data().first,g=mint::ntt_data().second;

    mint w[N+1];

    NTT(){
        w[N]=g;
        for(int i=N-1; i>=0; --i) w[i]=w[i+1]*w[i+1];
    }

    void trans(vector<mint> &a, int k, bool inv=false){
        for(int i=1,j=0; i<(1<<k); ++i){
            for(int t=1<<(k-1); (j^=t)<t; t>>=1);
            if(i<j) swap(a[i],a[j]);
        }
        for(int L=1,step=2; L<=k; ++L,step<<=1){
            for(int i=0; i<(1<<k); i+=step){
                mint cur(1),dw=w[L];
                for(int j=i,j2=i+(step>>1); j<i+(step>>1); ++j,++j2,cur*=dw){
                    mint tmp=a[j2]*cur;
                    a[j2]=a[j]-tmp;
                    a[j]+=tmp;
                }
            }
        }
        if(inv){
            reverse(a.begin()+1,a.end());
            mint inv=mint(1<<k).inv();
            for(int i=0; i<(1<<k); ++i) a[i]*=inv;
        }
    }
};// END: library/poly/ntt.hpp
#line 4 "library/poly/convolution.hpp"

template<typename mint>
vector<mint> convolution_naive(vector<mint> a, vector<mint> b){
    if(a.empty()||b.empty()) return {};
    int n=((int)a.size())+((int)b.size())-1;
    vector<mint> res(n);
    for(int i=0; i<((int)a.size()); ++i) for(int j=0; j<((int)b.size()); ++j){
        res[i+j]+=a[i]*b[j];
    }
    return res;
}

template<typename mint>
vector<mint> convolution_ntt(vector<mint> a, vector<mint> b){
    if(a.empty()||b.empty()) return {};
    static NTT<mint> ntt;
    int n=((int)a.size())+((int)b.size())-1;
    int m=1,k=0;
    while(m<n) m<<=1,k++;
    a.resize(m),b.resize(m);
    ntt.trans(a,k),ntt.trans(b,k);
    for(int i=0; i<m; ++i) a[i]*=b[i];
    ntt.trans(a,k,true);
    a.resize(n);
    return a;
}

template<typename mint>
vector<mint> convolution(vector<mint> a, vector<mint> b){
    if(a.empty()||b.empty()) return {};
    int n=((int)a.size())+((int)b.size())-1;
    if(mint::ntt_data().first<0||n<49) return convolution_naive(a,b);
    return convolution_ntt(a,b);
}// END: library/poly/convolution.hpp
#line 5 "library/poly/poly.hpp"

template<typename mint>
struct poly: vector<mint>{
    using vector<mint>::vector;

    poly(const vector<mint> &v):vector<mint>(v){}

    poly operator += (const poly &o){
        if(o.size()>this->size()) this->resize(o.size());
        for(int i=0; i<(int)o.size(); ++i) (*this)[i]+=o[i];
        return *this;
    }
    poly operator += (const mint &o){
        if(this->empty()) this->resize(1);
        (*this)[0]+=o;
        return *this;
    }
    poly operator -= (const poly &o){
        if(o.size()>this->size()) this->resize(o.size());
        for(int i=0; i<(int)o.size(); ++i) (*this)[i]-=o[i];
        return *this;
    }
    poly operator -= (const mint &o){
        if(this->empty()) this->resize(1);
        (*this)[0]-=o;
        return *this;
    }
    poly operator *= (const poly &o){
        return *this=convolution<mint>(*this,o);
    }
    poly operator *= (const mint &o){
        for(int i=0; i<(int)this->size(); ++i) (*this)[i]*=o;
        return *this;
    }
    poly operator + (const poly &o) const {return poly(*this)+=o;}
    poly operator + (const mint &o) const {return poly(*this)+=o;}
    poly operator - (const poly &o) const {return poly(*this)-=o;}
    poly operator - (const mint &o) const {return poly(*this)-=o;}
    poly operator * (const poly &o) const {return poly(*this)*=o;}
    poly operator * (const mint &o) const {return poly(*this)*=o;}

    poly interval(int l, int r){
        assert(l<=r&&r<=(int)this->size());
        poly res(this->begin()+l,this->begin()+r);
        return res;
    }

    poly inverse(){
        int n=this->size();
        assert((*this)[0]!=0);
        poly res(1,(*this)[0].inv());
        poly b=*this;
        for(int m=1; m<n; m<<=1){
            if(n<m*2) b.resize(m*2);
            poly v1=b.interval(0,m*2),v2=res;
            v1*=v2;
            v1.resize(m*2);
            v1*=v2;
            res.resize(m*2);
            for(int i=0; i<m; ++i) res[i]+=res[i];
            for(int i=0; i<m*2; ++i) res[i]-=v1[i];
        }
        res.resize(n);
        return res;
    }

    poly derivative(){
        int n=this->size();
        poly res(n-1);
        for(int i=0; i<n-1; ++i) res[i]=(*this)[i+1]*mint(i+1);
        return res;
    }

    poly integral(){
        int n=this->size();
        poly res(n+1);
        for(int i=0; i<n; ++i) res[i+1]=(*this)[i]*(inv<mint>(i+1));
        return res;
    }

    poly ln(){
        // a[0] = 1
        int n=this->size();
        if(n==1) return poly();
        poly d=derivative();
        poly b=*this;
        b.pop_back();
        poly res=d*b.inverse();
        res.resize(n-1);
        return res.integral();
    }

    poly exp(){
        // a[0] = 0
        int n=this->size();
        poly q(1,1);
        poly b=*this;
        b[0]+=1;
        for(int m=1; m<n; m<<=1){
            if(n<m*2) b.resize(m*2);
            poly g=b.interval(0,m*2),h=q;
            h.resize(m*2),h=h.ln();
            g-=h;
            q*=g;
            q.resize(m*2);
        }
        q.resize(n);
        return q;
    }

    poly pow_naive(ll k){
        int n=this->size();
        poly b=*this,res={1};
        for(; k; b*=b,k>>=1,b.resize(n)) if(k&1) res*=b,res.resize(n);
        return res;
    }

    int low(){
        int n=this->size(),m=0;
        while(m<n&&(*this)[m]==0) m++;
        if(m>=n) return -1;
        return m;
    }
    poly shift(int n){
        poly res(n,0);
        res.insert(res.end(),this->begin(),this->end());
        return res;
    }

    poly pow(ll k){ // 0^0 = 1
        int n=this->size();
        if(k==0){
            poly res(n);
            return res[0]=1,res;
        }
        int m=low();
        if(m){
            if(m==-1||k>=n||k*m>=n) return poly(n);
            int lft=n-k*m;
            poly b=interval(m,m+lft);
            b=b.pow(k);
            b=b.shift(k*m);
            return b;
        }
        poly b=*this;
        mint base=b[0].pow(k),inv=b[0].inv();
        b*=inv;
        b=b.ln();
        if(b.empty()) b.pb(0);
        b*=k;
        b=b.exp();
        b*=base;
        return b;
    }

    poly pow_sparse(int k, int n){ // 0^0 = 1
        if(k==0){
            poly res(n);
            return res[0]=1,res;
        }
        int t=this->size(),m=low();
        if(m){
            if(m==-1||k>=n||1ll*k*m>=n) return poly(n);
            int lft=n-k*m;
            poly b=interval(m,t);
            b=b.pow_sparse(k,lft);
            b=b.shift(k*m);
            return b;
        }
        poly res(n,0);
        res[0]=(*this)[0].pow(k);
        mint inv_a0=(*this)[0].inv();
        for(int i=1; i<n; ++i){
            for(int j=1; j<t; ++j){
                if(i-j>=0) res[i]-=res[i-j]*(i-j)*(*this)[j];
            }
            for(int j=1; j<t; ++j){
                if(i-j>=0) res[i]+=res[i-j]*(*this)[j]*j*k;
            }
            res[i]*=inv_a0*inv<mint>(i);
        }
        return res;
    }

    friend ostream& operator << (ostream& os, const poly &P){
        int n=P.size();
        for(int i=0; i<n; ++i){
            os << P[i];
            if(i+1<n) os << ' ';
        }
        os << "\n";
        return os;
    }
};// END: library/poly/poly.hpp
#line 115 "main.cpp"
using mint=montgomery_modint_32<49,true>;

void mango(){
    int n; ll m; int p; cin >> n >> m >> p;
    if(p==2){
        vi a(n); cin >> a;
        print(a[0]*m%2);
        return;
    }
    mint::set_mod(p);
    poly<mint> P(n+1);
    rep(i,1,n+1) cin >> P[i];
    poly<mint> p1,p2,cur={1};
    mint val=1;
    rep(n+1){
        if(i&1) p1+=cur*val*((i/2&1)?mint(-1):mint(1));
        else p2+=cur*val*((i/2&1)?mint(-1):mint(1));
        cur*=P;
        if(sz(cur)>n+1) cur.resize(n+1);
        val*=m-i;
        if(val==0) break;
        val/=i+1;
    }
    p2=p2.inverse();
    p1*=p2;
    rep(i,1,n+1) cout << p1[i] << ' ';
    cout << "\n";
}

signed main(){
    ios_base::sync_with_stdio(0),cin.tie(0);
    cout << fixed << setprecision(20);
    int t=1;
    //cin >> t;
    while(t--) mango();
}
// END: main.cpp