#include <cstdio>
#include <vector>

constexpr int MAXN = 100000 + 2;
constexpr int MAXLOGN = 17;

int n, id, siz[MAXN], pa[MAXN], minPt[MAXN], sePt[MAXN];
int pre[MAXN], dep[MAXN], lg[MAXN], st[MAXLOGN][MAXN];

long long totCnt[MAXN];

bool vis[MAXN];

std::vector<int> cur, cnt[MAXN], G[MAXN];

int _comp(int x, int y) {
    return dep[x] < dep[y] ? x : y;
}

int LCA(int x, int y) {
    if (x == y) {
        return x;
    }
    if ((x = pre[x]) > (y = pre[y])) {
        std::swap(x, y);
    }

    int k = lg[y - x];
    return _comp(st[k][x], st[k][y - (1 << k)]);
}

int dis(int x, int y) {
    return dep[x] + dep[y] - (dep[LCA(x, y)] << 1);
}

void DFS(int u, int fa) {
    st[0][id] = fa;
    pre[u] = ++ id;
    dep[u] = dep[fa] + 1;

    for (int v : G[u]) {
        if (v != fa) {
            DFS(v, u);
        }
    }
}

void init() {
    DFS(1, 0);

    for (int i = 2; i <= n; i ++) {
        lg[i] = lg[i >> 1] + 1;
    }
    for (int i = 1; i <= lg[n]; i ++) {
        for (int j = 1; j + (1 << i) <= n; j ++) {
            st[i][j] = _comp(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
        }
    }
}

void calSize(int u) {
    cur.push_back(u);
    vis[u] = true;
    siz[u] = 1;

    for (int v : G[u]) {
        if (!vis[v]) {
            calSize(v);
            siz[u] += siz[v];
        }
    }
    vis[u] = false;
}

int getRoot(int u) {
    cur.clear();
    calSize(u);

    int ret, minVal = n;

    for (int v : cur) {
        int maxSiz = siz[u] - siz[v];

        for (int w : G[v]) {
            if (!vis[w] && siz[w] < siz[v]) {
                maxSiz = std::max(maxSiz, siz[w]);
            }
        }
        if (minVal > maxSiz) {
            minVal = maxSiz;
            ret = v;
        }
    }

    return ret;
}

void add(int u, int op) {
    int p1 = minPt[u];
    int p2 = sePt[u];

    if (p2 == cnt[u].size()) {
        return;
    }

    if (p1 == p2) {
        totCnt[p1 << 1] += cnt[u][p1] * (cnt[u][p1] - 1ll) * op >> 1;
    } else {
        totCnt[p1 + p2] += cnt[u][p2] * op;
    }
}

void move(int u) {
    int &p1 = minPt[u];
    int &p2 = sePt[u];

    if (!cnt[u][p1]) {
        p1 = p2;
    }

    if (p2 < cnt[u].size() && cnt[u][p2] == (p1 == p2)) {
        p2 ++;
    }
    while (p2 < cnt[u].size() && !cnt[u][p2]) {
        p2 ++;
    }
}

void solve(int rt, int fa) {
    pa[rt] = fa;
    vis[rt] = true;

    cnt[rt].resize(cur.size() + 1);
    for (int i = 0; i <= cur.size(); i ++) {
        cnt[rt][i] = 0;
    }
    for (int u : cur) {
        cnt[rt][dis(u, rt)] ++;
    }

    move(rt);
    add(rt, 1);

    for (int u : G[rt]) {
        if (!vis[u]) {
            solve(getRoot(u), rt);
        }
    }
}

void modify(int x) {
    int u = x;
    while (u) {
        add(u, -1);
        cnt[u][dis(x, u)] --;
        move(u);
        add(u, 1);
        u = pa[u];
    }
}

int main() {
    int tp;
    scanf("%d%d", &n, &tp);

    for (int i = 1, u, v; i < n; i ++) {
        scanf("%d%d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }

    init();
    solve(getRoot(1), 0);

    long long lastAns = 0;
    int ans = 0;

    for (int i = 0; i < n - 2; i ++) {
        long long x;
        scanf("%lld", &x);

        modify(x ^= lastAns * tp);

        while (!totCnt[ans]) {
            ans ++;
        }
        printf("%d %lld\n", ans, lastAns = totCnt[ans]);
    }

    return 0;
}