// Original C++ solution (slower):
#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <iostream>

#include <istream>

#include <iterator>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <vector>

#include <tuple>

#include <iomanip>

using namespace std;



typedef long long ll;

typedef unsigned long long ull;

//typedef pair<ll, ll> P;

typedef vector<ll> vec;

typedef vector<vec> mat;

#define rep(i, n) for(ll i = 0; i < (n); i++)

#define revrep(i, n) for(ll i = (n)-1; i >= 0; i--)

#define pb push_back

#define f first

#define s second

/*

ll max(ll a, ll b){return (a > b) ? a : b;}

ll min(ll a, ll b){return (a < b) ? a : b;}

ll max3(ll a, ll b, ll c){return max(a, max(b, c));};

ll min3(ll a, ll b, ll c){return min(a, min(b, c));};

ll max4(ll a, ll b, ll c, ll d){return max(max(a, b), min(c, d));};

ll min4(ll a, ll b, ll c, ll d){return min(min(a, b), min(c, d));};

ll max5(ll a, ll b, ll c, ll d, ll e){return max(max(a, b), max3(c, d, e));};

ll min5(ll a, ll b, ll c, ll d, ll e){return min(min(a, b), min3(c, d, e));};

*/

const ll INFL = 1LL << 60;//10^18 = 2^60

const int INF = 1 << 30;//10^9

ll MOD = 1000000007;

//ll MOD = 998244353;



vector<ll> dy = {0, 0, 1, -1, 1, 1, -1, -1, 0};

vector<ll> dx = {1, -1, 0, 0, 1, -1, 1, -1, 0};



//デバッグ

void BinarySay(ll x, ll y = 60){rep(i, y) cout << (x>>(y-1-i) & 1); cout << endl;}



ll pow_long(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2) res *= x;

    x *= x;

    k /= 2;

  }

  return res;

}

ll pow_mod(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2){

      res *= x; res %= MOD;

    }

    x *= x; x %= MOD;

    k /= 2;

  }

  return res;

}



ll inverse(ll x){return pow_mod(x, MOD - 2);};



ll gcd(ll a, ll b){

    if(b == 0) return a;

    return gcd(b, a % b);

}



ll lcm(ll x, ll y){return x / gcd(x, y) * y;};





ll kai_mod(ll x){

  if(x == 0) return 1;

  return x * kai_mod(x-1) % MOD;

}





//コンビネーション

const int MAXcomb = 200010;

ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];

//facはn!,finvは1/n!

//invは逆元

void COMinit(){

    fac[0] = fac[1] = 1;

    finv[0] = finv[1] = 1;

    inv[1] = 1;

    for(int i = 2; i < MAXcomb; i++){

        fac[i] = fac[i-1] * i % MOD;

        inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;

        finv[i] = finv[i-1] * inv[i] % MOD;

    }

}

ll comb(int n, int k){

    if(n < k) return 0;

    if(n < 0 || k < 0) return 0;

    return fac[n] * finv[k] % MOD * finv[n-k] % MOD;

}



ll N, M;

vector<ll> E[100010];

vector<ll> D(100010);

vector<ll> Par(100010);

vector<ll> ans(100010);

ll dfs(ll now, ll from){

  ll res = 1;

  for(ll to : E[now]){

    if(to == from) continue;

    res *= (dfs(to, now) + 1);

    res %= M;

  }

  return D[now] = res;

}



void dfsPar(ll now, ll from){

  ans[now] = (D[now] + D[now] * Par[now]) % M;

  vector<ll> sekiPre(E[now].size() + 1);

  sekiPre[0] = 1;

  rep(i, E[now].size()){

    if(E[now][i] == from) sekiPre[i+1] = sekiPre[i];

    else sekiPre[i+1] = sekiPre[i] * (D[E[now][i]]+1) % M;

  }

  vector<ll> sekiSuf(E[now].size() + 1);

  sekiSuf[E[now].size()] = 1;

  revrep(i, E[now].size()){

    if(E[now][i] == from) sekiSuf[i] = sekiSuf[i+1];

    else sekiSuf[i] = sekiSuf[i+1] * (D[E[now][i]]+1) % M;

  }



  rep(i, E[now].size()){

    ll to = E[now][i];

    if(to == from) continue;

    Par[to] = (1 + Par[now]) * sekiPre[i] % M * sekiSuf[i+1] % M;

    dfsPar(to, now);

  }

}



void solve(){

  dfs(0, -1);

  dfsPar(0, -1);

  rep(i, N){

    cout << ans[i] << endl;

  }

}



int main(){

  cin >> N >> M;

  rep(i, N-1){

    ll x, y;

    cin >> x >> y;

    x--, y--;

    E[x].pb(y);

    E[y].pb(x);

  }

  solve();

}


// Optimized solution to the same problem (faster):
#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <iostream>

#include <istream>

#include <iterator>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <vector>

#include <tuple>

#include <iomanip>

#include <climits>

using namespace std;



typedef long long ll;

typedef unsigned long long ull;

//typedef pair<ll, ll> P;

#define rep(i, n) for(ll i = 0; i < (n); i++)

#define revrep(i, n) for(ll i = (n)-1; i >= 0; i--)

#define pb push_back

#define f first

#define s second

#define chmin(x, y) x = min(x, y);

#define chmax(x, y) x = max(x, y);



//const ll INFL = LLONG_MAX;//10^18 = 2^60

const ll INFL = 1LL<<60;

//const int INF = INT_MAX;

const ll INF = 1 << 30;//10^9

ll MOD = 1000000007;

//ll MOD = 998244353;



vector<ll> dy = {0, 1, 0, -1, 1, 1, -1, -1, 0};

vector<ll> dx = {1, 0, -1, 0, 1, -1, 1, -1, 0};



void pres(double A, ll x = 20){cout << fixed << setprecision(x) << A << endl;}

void BinarySay(ll x, ll y = 60){rep(i, y) cout << (x>>(y-1-i) & 1); cout << endl;}

ll cnt_bit(ll x){return __builtin_popcountll(x);}



ll pow_long(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2) res *= x;

    x *= x; k /= 2;

  }

  return res;

}



ll pow_mod(ll x, ll k){

  ll res = 1;

  while(k > 0){

    if(k % 2){

      res *= x; res %= MOD;

    }

    x *= x; x %= MOD;

    k /= 2;

  }

  return res;

}



ll inverse(ll x){return pow_mod(x, MOD - 2);};



ll gcd(ll a, ll b){

    if(b == 0) return a;

    return gcd(b, a % b);

}



ll lcm(ll x, ll y){

  ll res = x / gcd(x, y);

  res *= y;

  return res;

};



/*

//コンビネーション

const int MAXcomb = 200010;

ll fac[MAXcomb], finv[MAXcomb], inv[MAXcomb];

//facはn!,finvは1/n!

//invは逆元

void COMinit(){

    fac[0] = fac[1] = 1;

    finv[0] = finv[1] = 1;

    inv[1] = 1;

    for(int i = 2; i < MAXcomb; i++){

        fac[i] = fac[i-1] * i % MOD;

        inv[i] = MOD - inv[MOD%i] * (MOD/i) % MOD;

        finv[i] = finv[i-1] * inv[i] % MOD;

    }

}

ll comb(int n, int k){

    if(n < k) return 0;

    if(n < 0 || k < 0) return 0;

    return fac[n] * finv[k] % MOD * finv[n-k] % MOD;

}



const int MAXkai = 200010;

ll kai_memo[MAXkai];

ll kai(ll N){

  if(kai_memo[N] != 0) return kai_memo[N];

  if(N <= 1) return 1;

  return kai_memo[N] = N * kai(N-1) % MOD;

}

*/



ll N;

vector<ll> E[100010];

ll dp[100010];



ll dfs(ll now, ll from){

  ll res = 1;

  for(ll to: E[now])if(to != from){

    res *= dfs(to, now) + 1;

    res %= MOD;

  }

  return dp[now] = res;

}



ll Dar[100010];

void dfs2(ll now, ll from){

  vector<ll> xs;

  vector<ll> TO;

  for(ll to: E[now])if(to != from){

    xs.pb(dp[to] + 1);

    TO.pb(to);

  }

  ll M = xs.size();

  vector<ll> left(M+1), right(M+1);

  left[0] = 1;

  right[M] = 1;

  rep(i, M) left[i+1] = left[i] * xs[i] % MOD;

  revrep(i, M) right[i] = right[i+1] * xs[i] % MOD;

  rep(i, M){

    Dar[TO[i]] = Dar[now] * left[i] % MOD * right[i+1] % MOD + 1;

  }

  rep(i, M) dfs2(TO[i], now);

}



ll sum[100010];

void dfs3(ll now, ll from){

  sum[now] += dp[now];

  sum[now] %= MOD;

  for(ll to: E[now])if(to != from){

    sum[to] += sum[now];

    sum[to] %= MOD;

    dfs3(to, now);

  }

}



void solve(){

  cin >> N >> MOD;

  rep(i, N-1){

    ll a, b;

    cin >> a >> b;

    a--, b--;

    E[a].pb(b);

    E[b].pb(a);

  }

  Dar[0] = 1;

  dfs(0, -1);

  dfs2(0, -1);

  dfs3(0, -1);

  rep(i, N){

    ll ans = Dar[i] * dp[i] % MOD;

    cout << ans << endl;

  }

}



int main(){

  cin.tie(0);

  ios::sync_with_stdio(false);

  solve();

}


// Fastest known solution for this problem: