#include <bits/stdc++.h>

using ll = long long;
using namespace std;

vector<int> g[200500];
int c[200500];

namespace simple_st {

    struct Info {
        int max = -1e7;
        int cnt_max = 0;
        int second_max = -1e7;

        Info() = default;
        Info(int d) {
            max = d;
            cnt_max = 1;
        }
    };

    Info operator+(const Info &A, const Info &B) {
        Info C;
        if (A.max > B.max) {
            C.max = A.max;
            C.cnt_max = A.cnt_max;
            C.second_max = max(A.second_max, B.max);
        } else if (B.max > A.max) {
            C.max = B.max;
            C.cnt_max = B.cnt_max;
            C.second_max = max(B.second_max, A.max);
        } else {
            C.max = A.max;
            C.cnt_max = A.cnt_max + B.cnt_max;
            C.second_max = A.max;
        }
        return C;
    }

    static constexpr int size = 1 << 18;

    Info info[size * 2 - 1];
    int tag[size * 2 - 1];

    void apply(int x, int v) {
        info[x].max += v;
        info[x].second_max += v;
        tag[x] += v;
    }

    void push(int x) {
        if (tag[x]) {
            apply(x * 2 + 1, tag[x]);
            apply(x * 2 + 2, tag[x]);
            tag[x] = 0;
        }
    }

    void set(int i, int v, int x = 0, int lx = 0, int rx = size) {
        if (rx - lx == 1) {
            info[x] = Info(v);
            return;
        }

        push(x);

        if (i < (lx + rx) / 2) {
            set(i, v, x * 2 + 1, lx, (lx + rx) / 2);
        } else {
            set(i, v, x * 2 + 2, (lx + rx) / 2, rx);
        }

        info[x] = info[x * 2 + 1] + info[x * 2 + 2];
    }

    void add(int l, int r, int v, int x = 0, int lx = 0, int rx = size) {
        if (l <= lx && rx <= r) {
            apply(x, v);
            return;
        }

        if (l >= rx || lx >= r) {
            return;
        }

        push(x);

        add(l, r, v, x * 2 + 1, lx, (lx + rx) / 2);
        add(l, r, v, x * 2 + 2, (lx + rx) / 2, rx);

        info[x] = info[x * 2 + 1] + info[x * 2 + 2];
    }

    int find_max(int x = 0, int lx = 0, int rx = size) {
        if (rx - lx == 1) {
            return lx;
        }

        push(x);

        if (info[x * 2 + 1].max == info[x].max) {
            return find_max(x * 2 + 1, lx, (lx + rx) / 2);
        } else {
            return find_max(x * 2 + 2, (lx + rx) / 2, rx);
        }
    }
} // namespace simple_st

vector<int> et;
int et_num[200500];
int tail[200500];

void set_dist(int u, int p = -1, int d = 0) {
    et_num[u] = et.size();
    et.push_back(u);

    if (g[u].size() == 1) {
        simple_st::set(et_num[u], d);
    }

    for (int v : g[u]) {
        if (v != p) {
            set_dist(v, u, d + 1);
        }
    }

    tail[u] = et.size();
}

multiset<int> taill[200500];
int ans[200500];

bool contains(int l, int r, int x) {
    for (int i = l; i <= r; i++) {
        if (c[et[i]] == x) {
            return true;
        }
    }
    return false;
}

int count(int l, int r) {
    multiset<int> Q;
    for (int i = l; i <= r; i++) {
        Q.insert(c[et[i]]);
    }
    return Q.size();
}

void dfs(int u, int p = -1) {

    if (simple_st::info[0].cnt_max == 1) {
        int k = et[simple_st::find_max()];

        int diff = (simple_st::info[0].max - simple_st::info[0].second_max);

        int x = count(et_num[k] - diff + 1, et_num[k]);

        if (g[u].size() == 1) {
            for (int v : taill[u]) {
                if (!contains(et_num[k] - diff + 1, et_num[k], v)) {
                    x += 1;
                }
            }
        }

        ans[u] = x;
    } else if (g[u].size() == 1) {
        ans[u] = taill[u].size();
    }

    for (int v : g[u]) {
        if (v != p) {
            simple_st::add(0, et.size(), 1);
            simple_st::add(et_num[v], tail[v], -2);
            dfs(v, u);
            simple_st::add(0, et.size(), -1);
            simple_st::add(et_num[v], tail[v], 2);
        }
    }
}

signed main() {
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#else
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#endif

    int n, m;
    cin >> n >> m;

    if (n == 2) {
        cout << "1\n1\n";
        return 0;
    }

    for (int i = 0; i < n - 1; i++) {
        int u, v;
        cin >> u >> v;

        g[u].push_back(v);
        g[v].push_back(u);
    }

    for (int u = 1; u <= n; u++) {
        cin >> c[u];
    }

    int root = 1;
    for (int u = 1; u <= n; u++) {
        if (g[u].size() > 1) {
            root = u;
        }

        if (g[u].size() == 1) {

            int last = -1;
            int v = u;

            while (true) {
                if (g[v].size() > 2) {
                    break;
                }

                int cnt = 0;
                for (int k : g[v]) {
                    if (k != last) {
                        cnt += 1;
                    }
                }

                if (cnt == 1) {
                    for (int k : g[v]) {
                        if (k != last) {
                            last = v;
                            v = k;
                            break;
                        }
                    }
                } else {
                    break;
                }

                taill[u].insert(c[v]);
            }
        }
    }

    set_dist(root);
    dfs(root);

    for (int u = 1; u <= n; u++) {
        cout << ans[u] << "\n";
    }
    return 0;
}