#include <bits/stdc++.h>
#define REP(i, n) for(int i=0; i<(int)(n); i++)
#define REP1(i,a,b) for(int i=a; i<=(int)(b); i++)
#define ALL(x) begin(x),end(x)
#define PB push_back
using namespace std;
typedef int64_t LL;
typedef vector<int> VI;
typedef pair<int,int> PII;

template<class T> inline bool chmax( T &a, const T &b ) { return b>a ? a=b,true : false; }
template<class T> inline bool chmin( T &a, const T &b ) { return b<a ? a=b,true : false; }
template<class T> using MaxHeap = priority_queue<T>;
template<class T> using MinHeap = priority_queue<T, vector<T>, greater<T>>;
template<class T, class F=less<T>> void sort_uniq( vector<T> &v, F f=F() ) {
    sort(begin(v),end(v),f);
    v.resize(unique(begin(v),end(v))-begin(v));
}

// {{{ ModInt
// template<int _MOD>
int MOD;
struct ModInt {
    // static const auto MOD = _MOD;
    template<class T> using integral_only = typename enable_if<is_integral<T>::value>::type;

    int x;   
    constexpr ModInt() : x() {}

    template<class T, integral_only<T>* = nullptr>
    ModInt(T _x=0) {
        x = _x % MOD;
        if(x<0) x+=MOD;
    }
    ModInt operator-() const { return {x == 0? 0 : MOD-x}; }
    ModInt& operator+=(const ModInt a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator-=(const ModInt a) {
        if ((x += MOD-a.x) >= MOD) x -= MOD;
        return *this;
    }
    ModInt& operator*=(const ModInt a) {
        x = (long long)x * a.x % MOD;
        return *this;
    }
    ModInt& operator/=(const ModInt a) {
        return (*this) *= a.inv();
    }

    ModInt operator+(const ModInt a) const { return ModInt(*this) += a; }
    ModInt operator-(const ModInt a) const { return ModInt(*this) -= a; }
    ModInt operator*(const ModInt a) const { return ModInt(*this) *= a; }
    ModInt operator/(const ModInt a) const { return ModInt(*this) /= a; }
    ModInt inv() const {
        // for prime MOD
        return pow(MOD-2);
    }
    ModInt inv2() const {
        // work for non-prime MOD if gcd(x,MOD) = 1
        int a = x, b = MOD, u = 1, v = 0;
        while(b != 0) {
            int t = a / b;
            a -= t * b;
            u -= t * v;
            swap(a, b);
            swap(u, v);
        }
        return u;
    }
    template<class T, integral_only<T>* = nullptr>
    ModInt pow(T t) const {
        ModInt r = 1, p = *this;
        while(t) {
            if(t & 1) r *= p;
            p *= p;
            t >>= 1;
        }
        return r;
    }

    bool operator==(ModInt rhs) const { return x == rhs.x; }
    bool operator!=(ModInt rhs) const { return x != rhs.x; }
    bool operator<(ModInt rhs) const { return x < rhs.x; }
    bool operator<=(ModInt rhs) const { return x <= rhs.x; }
    bool operator>(ModInt rhs) const { return x > rhs.x; }
    bool operator>=(ModInt rhs) const { return x >= rhs.x; }

    friend string to_string(ModInt i) { return to_string(i.x); }
    friend istream& operator>>(istream&i,ModInt&a) { return i>>a.x; }
    friend ostream& operator<<(ostream&o,const ModInt&a) { return o<<a.x; }
};

// }}}
using mint = ModInt;

int main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n;
    cin >> n >> MOD;
    vector<vector<int>> g(n);
    for ( int i=0; i<n-1; i++ ) {
        int x,y;
        cin >> x >> y;
        --x; --y;
        g[x].push_back(y);
        g[y].push_back(x);
    }
    vector<int> pv(n,-1);
    vector<mint> dp(n);
    function<void(int)> Dfs=[&](int v) {
        dp[v]=1;
        for ( int u:g[v] ) {
            if ( u==pv[v] ) {
                continue;
            }
            pv[u]=v;
            Dfs(u);
            dp[v]*=dp[u]+1;
        }
    };
    Dfs(0);
    vector<mint> res(n);
    function<void(int, mint)> Solve=[&](int v, mint up) {
        res[v]=dp[v]*up;
        vector<int> children;
        for ( int u:g[v] ) {
            if ( u==pv[v] ) {
                continue;
            }
            children.push_back(u);
        }
        int cnt=(int)children.size();
        vector<mint> pref(cnt+1);
        pref[0]=1;
        for ( int i=0; i<cnt; i++ ) {
            pref[i+1]=pref[i]*(dp[children[i]]+1);
        }
        vector<mint> suf(cnt+1);
        suf[cnt]=1;
        for ( int i=cnt-1; i>=0; i-- ) {
            suf[i]=suf[i+1]*(dp[children[i]]+1);
        }
        for ( int i=0; i<cnt; i++ ) {
            Solve(children[i], up*pref[i]*suf[i+1]+1);
        }
    };
    Solve(0,1);
    for ( int i=0; i<n; i++ ) {
        cout << res[i] << '\n';
    }
    return 0;
}

Measured memory_bytes: 23680