#include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>

#define _overload(_1,_2,_3,name,...) name
#define _rep(i,n) _range(i,0,n)
#define _range(i,a,b) for(int i=int(a);i<int(b);++i)
#define rep(...) _overload(__VA_ARGS__,_range,_rep,)(__VA_ARGS__)

#define _rrep(i,n) _rrange(i,n,0)
#define _rrange(i,a,b) for(int i=int(a)-1;i>=int(b);--i)
#define rrep(...) _overload(__VA_ARGS__,_rrange,_rrep,)(__VA_ARGS__)

#define _all(arg) begin(arg),end(arg)
#define uniq(arg) sort(_all(arg)),(arg).erase(unique(_all(arg)),end(arg))
#define getidx(ary,key) lower_bound(_all(ary),key)-begin(ary)
#define clr(a,b) memset((a),(b),sizeof(a))
#define bit(n) (1LL<<(n))
#define popcount(n) (__builtin_popcountll(n))

using namespace std;

template<class T>bool chmax(T &a, const T &b) { return (a<b)?(a=b,1):0;}
template<class T>bool chmin(T &a, const T &b) { return (b<a)?(a=b,1):0;}

using ll=long long;
using R=long double;
const R EPS=1e-9L; // [-1000,1000]->EPS=1e-8 [-10000,10000]->EPS=1e-7
inline int sgn(const R& r){return(r > EPS)-(r < -EPS);}
inline R sq(R x){return sqrt(max(x,0.0L));}

const int dx[8]={1,0,-1,0,1,-1,-1,1};
const int dy[8]={0,1,0,-1,1,1,-1,-1};

const pid_t pid = getpid();
// Problem Specific Parameter:
#define error(args...) { vector<string> _debug = split(#args, ',');err(begin(_debug), args);}

vector<string> split(const string& s, char c){
	vector<string> v;stringstream ss(s);string x;
	while (getline(ss, x, c)) v.emplace_back(x);
	return move(v);
}

void err(vector<string>::iterator it) {cerr << endl;}
template<typename T, typename... Args> void err(vector<string>::iterator it, T a,Args... args){
	cerr << it -> substr((*it)[0] == ' ', it -> length()) << " = " << a << " ",err(++it, args...);
}


const int limit = 100010;
int n,m;

vector<int> graph[limit];
bool flag[limit];
vector<int> lft[limit];
vector<int> rht[limit];

//Appropriately Changed
void add_edge(int from, int to) {
	graph[from].push_back(to);
	graph[to].push_back(from);
}

map<int,int> dp[limit];

void dfs(int v,int p){
	if(dp[v].find(p) != end(dp[v])) return;
	int res = 1LL;
	rep(i,graph[v].size()){
		const int to = graph[v][i];
		if(to == p) continue;
		dfs(to, v);
		const int tmp = (dp[to][v] + 1) % m;
		res = 1LL * res * tmp % m;
	}
	dp[v][p] = res;
}

void memo_compute(int v){
	//error(v);
	const int l = graph[v].size();
	lft[v].resize(l);
	rht[v].resize(l);

	int cur = 1;
	rep(i,l){
		const int to = graph[v][i];
		const int tmp = (dp[to][v] + 1) % m;
		cur = 1LL * cur * tmp % m;
		lft[v][i] = cur;
	}

	cur = 1;
	rrep(i,l){
		const int to = graph[v][i];
		const int tmp = (dp[to][v] + 1) % m;
		cur = 1LL * cur * tmp % m;
		rht[v][i] = cur;
	}
}


void dfs2(int v,int p){
	if(p != -1) {
		const int idx = getidx(graph[p],v);
		const int l = graph[p].size();
		ll res = 1LL;
		if(idx - 1 >= 0) res = res * lft[p][idx - 1] % m;
		if(idx + 1 <  l) res = res * rht[p][idx + 1] % m;
		dp[p][v] = res;
	}

	memo_compute(v);

	rep(i,graph[v].size()){
		const int to = graph[v][i];
		if(to == p) continue;
		dfs2(to, v);
	}
}

int main(void){
	cin >> n >> m;

	rep(i,n-1){
		int a,b;
		cin >> a >> b;
		add_edge(a-1,b-1);
	}

	if(n == 1){
		puts("1");
		return 0;
	}

	rep(v,n) sort(begin(graph[v]),end(graph[v]));
	
	dfs(0, -1);
	dfs2(0, -1);
	
	rep(v,n) cout << rht[v][0] << endl;

	return 0;
}

Measured memory_bytes: 38272