#include <cstdio>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <cctype>
#include <set>

namespace uvu
{
// #define LOCAL ____________DONT_DEFINE_ME____________
#define ll long long
#define inf 0x3f3f3f3f
// #define int long long
// #define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 20);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
	return getchar();
#else
	if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
	return iS == iT ? EOF : *iS++;
#endif
#define getchar ERR
}

void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher(){ Flush(); } }iamflusher;

void putc(char c)
{
#ifdef LOCAL
	putchar(c);
#else
	*oS++ = c;
	if(oS == oT) Flush();
#endif
#define putchar ERR
}

template <typename T = int> T read()
{
	T x = 0, f = 1; char c = getc();
	for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
	for(;  isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
	return x * f;
}

template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
	top = 0;
	if(x < 0) putc('-'), x = -x;
	if(!x) sta[top = 1] = 0;
	for(; x; x /= 10) sta[++top] = x % 10;
	for(; top; ) putc(sta[top--] ^ 48);
	if(c) putc(c);
}

int readstr(char *s, int base)
{
	int idx = base - 1; char c = getc();
	for(; !(isdigit(c) || isalpha(c) || c == '#' || c == '.'); c = getc());
	for(;   isdigit(c) || isalpha(c) || c == '#' || c == '.' ; c = getc()) s[++idx] = c;
	return idx - base + 1;
}

void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args>
void printf(const char *s, T x, Args ... rest)
{
	for(; *s; s++)
	{
		if(*s != '%') { putc(*s); continue; }
		s++; if(*s == 'd') print(x, 0);
		else if(*s == 'c') putc(x);
		printf(s + 1, rest ...);
		return;
	}
}

template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
#define mod 998244353
// #define mod 1000000007
int sm(int x) { return x >= mod ? x - mod : x; }
void plus_(int &x, int y) { x = sm(x + y); }
void mul_(int &x, int y) { x = 1ll * x * y % mod; }
int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }

#define N 500010
int n, OP;
int h[N], e[N << 1], ne[N << 1], idx = -1;
void add_edge(int x, int y) { ne[++idx] = h[x], h[x] = idx, e[idx] = y; }
void add(int x, int y) { add_edge(x, y), add_edge(y, x); }
pii val[N];
ll ans[N << 1]; int now;
int root, minnum, full, sz[N];
bool vis[N];
void getroot(int k, int fa)
{
	int maxnum = 0; sz[k] = 1;
	for(int i = h[k]; ~i; i = ne[i]) if(e[i] != fa && !vis[e[i]])
		getroot(e[i], k), sz[k] += sz[e[i]], ckmax(maxnum, sz[e[i]]);
	ckmax(maxnum, full - sz[k]); if(maxnum < minnum) minnum = maxnum, root = k;
}
void Getroot(int k, int f) { full = f; minnum = inf; getroot(k, 0); }
int Dep[N][22], Fa[N], from[N];
std::vector <int> cnt[N];
int posmn[N], posse[N];

void dfs(int k, int fa, int dep, int b, int rt)
{
	Dep[k][b] = dep; sz[k] = 1;
	if((int)cnt[rt].size() <= dep) cnt[rt].resize(dep + 1);
	cnt[rt][dep]++;
	for(int i = h[k]; ~i; i = ne[i]) if(e[i] != fa && !vis[e[i]]) dfs(e[i], k, dep + 1, b, rt), sz[k] += sz[e[i]]; 
}

void calc(int k, int z)
{
	if(posmn[k] >= (int)cnt[k].size()) return;
	if(cnt[k][posmn[k]] >= 2) ans[posmn[k] * 2] += 1ll * cnt[k][posmn[k]] * (cnt[k][posmn[k]] - 1) / 2 * z;
	else if(posse[k] >= (int)cnt[k].size()) return;
	else ans[posmn[k] + posse[k]] += 1ll * cnt[k][posse[k]] * z;
}

void sv(int k, int dep)
{
	vis[k] = 1; from[k] = dep;
	dfs(k, 0, 0, dep, k);
	posmn[k] = 0;            while(posmn[k] < (int)cnt[k].size() && !cnt[k][posmn[k]]) posmn[k]++;
	posse[k] = posmn[k] + 1; while(posse[k] < (int)cnt[k].size() && !cnt[k][posse[k]]) posse[k]++;
	calc(k, 1);
	for(int i = h[k]; ~i; i = ne[i]) if(!vis[e[i]]) Getroot(e[i], sz[e[i]]), Fa[root] = k, sv(root, dep + 1);
}

void del(int x)
{
	int k = x, p = from[x];
	while(k)
	{
		calc(k, -1);
		cnt[k][Dep[x][p]]--;
		while(posmn[k] < (int)cnt[k].size() && !cnt[k][posmn[k]]) posmn[k]++;
		ckmax(posse[k], posmn[k] + 1);
		while(posse[k] < (int)cnt[k].size() && !cnt[k][posse[k]]) posse[k]++;
		calc(k, 1);
		k = Fa[k], p--;
	}
}

void solve()
{
	memset(h, idx = -1, sizeof(h));
	n = read(), OP = read();
	for(int i = 1; i < n; i++) add(read(), read());
	Getroot(1, n); sv(root, 0);
	ll lastans = 0;
	for(int _ = 1; _ <= n - 2; _++)
	{
		int x = read<ll>() ^ (lastans * OP);
		del(x);
		while(!ans[now]) now++;
		print(now, ' ');
		print(lastans = ans[now], '\n');
	}
}

void init()
{
	
}

char _ED_;

void mian()
{
	debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
	init();
	for(int T = 1; T; solve(), T--);
}

#ifdef int
	#undef int
#endif
}

int main()
{
	// freopen("tmp.in", "r", stdin);
	// freopen("tmp.out", "w", stdout);
	uvu::mian(); return 0;
}