#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define FASTIO
#define endl "\n"  // Since endl forces a buffer flush which slows down large I/O operations.
#define ff first
#define ss second
#define pb push_back
#define input(c, n) for (int i = 0; i < n; ++i) cin >> c[i];
#define exit_message(s) return 0 * printf(s)
#define show_all(c) for (auto i: c) cout << i << " "; cout << "\n";
#define display(c, a, n) cout << "Displaying array \"" << #c << "\" : \n"; for (int (i) = (a); (i) < (n); ++(i)) cout << (c)[(i)] << " "; cout << "\n";
#define forl(i, a, n) for (int i = (a); (i) < (n); ++(i))
#define dugbe(k) cout << "-\t> " << #k << " : " << k << "\n";
#define dugbev(vec, idx) cout << "-\t> " << #vec << "[" << idx << "] : " << vec[idx] << "\n";

// What follows is a magical ordered set data structure.
// Supports the following functions:
// find_by_order(int k) - returns k'th smallest element (0-indexed)
// order_of_key(int k) - returns number of elements strictly smaller than k.

// using namespace __gnu_pbds;
// #define ordered_set tree <ll, null_type, greater_equal <ll>, rb_tree_tag, tree_order_statistics_node_update>

/* TIPS FOR DEBUGGING
 * Check if values are not overflowing (use long long where required)
 * Check if ranges are inclusive or not.
 * Check properly if greedy will work or not before using it.
 * Check EDGE CASES!! Seriously, even in 2B, saving 8 points by being
 * 2 minutes faster will bite you in the ass if you don't make sure
 * it works on edge cases.
 * Keep adding to this list.
*/

using namespace std;
typedef long long ll;
typedef pair<int, int> pr;
typedef pair<ll, ll> prll;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<pr> vpr;
ifstream in("input.txt");
const ll mod = 1e9 + 7;
const long double eps = 1e-7;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

long long true_rand(long long n)
{
	// Returns a random number between 0 and n - 1 inclusive using mt19937.
    uniform_int_distribution<long long> uid(0, n - 1);
    return uid(rng);
}

ll mod_pow(ll a, ll b)
{
	if (b == 0)
		return 1LL;

	ll res = mod_pow(a, b >> 1);
	res = (res * res) % mod;
	if (b & 1LL)
		res = (res * a) % mod;
	
	return res;
}

const int N = 50 + 5, INF = 1e9 + 100;

int n, M;
vector<vector<int>> g;
vector<int> dp;

void add_self(int &a, int b)
{
	a += b;
	a %= M;
}

void mul_self(int &a, int b)
{
	a = (ll)a * b % M;
}

void dfs(int s, int par)
{
	// dugbe(s);
	// dugbe(par);
	dp[s] = 1;
	for (auto e: g[s])
	{
		if (e == par)
			continue;
		dfs(e, s);
		mul_self(dp[s], 1 + dp[e]);
	}

	// dp[s] now stores the no. of black trees where
	// 's' is the root.
}

void sum_dp(int s, int par, int val)
{
	// cout << "s : " << s << " par : " << par << " val : " << val << "\n";

	// val is the number of black trees where 's' is a leaf.

	int len = (int)g[s].size();
	vector<int> lef(len + 1, 1), rig(len + 1, 1);
	forl(i, 1, len + 1)
	{
		int e = g[s][i - 1];
		lef[i] = lef[i - 1];
		if (e != par)
			mul_self(lef[i], 1 + dp[e]);
		// lef[k] represents pi(dp[k - 1])
	}
	for (int i = len - 1; i >= 0; --i)
	{
		int e = g[s][i];
		rig[i] = rig[i + 1];
		if (e != par)
			mul_self(rig[i], 1 + dp[e]);
		// rig[k] represents rev_pi(dp[k])
	}
	// forl(i, 0, len + 1)
	// {
	// 	cout << i << " : " << lef[i] << " " << rig[i] << "\n";
	// }
	forl(i, 0, len)
	{
		int e = g[s][i];
		if (e == par)
			continue;

		int rem_prod = lef[i];
		mul_self(rem_prod, rig[i + 1]);
		mul_self(rem_prod, val);

		mul_self(dp[e], rem_prod + 1);

		sum_dp(e, s, rem_prod + 1);
	}
}

int32_t main()
{
	#ifdef FASTIO
		ios_base::sync_with_stdio(false);
		cin.tie(NULL);
	#endif
	// freopen("input.txt", "r", stdin);
	// freopen("output.txt", "w", stdout);

	cin >> n >> M;
	g.resize(n);
	forl(i, 0, n - 1)
	{
		int u, v;
		cin >> u >> v;
		--u, --v;
		g[u].pb(v);
		g[v].pb(u);
	}
	dp.assign(n, 0);
	dfs(0, -1);
	sum_dp(0, -1, 1);
	forl(i, 0, n)
	{
		cout << dp[i] << "\n";
	}

	return 0;
}

Measured memory_bytes: 18304