#include <bits/stdc++.h>
using namespace std;
struct LCA{
    vector<vector<int>> parent;
    vector<int> depth;
    vector<vector<int>> G;
    int N;
    LCA(){}
    LCA(vector<vector<int>> &g) : N(g.size()), depth(g.size()), G(g){
        parent.resize(41, vector<int>(N));
    }
    LCA(int n): N(n), depth(n), G(n){
        parent.resize(41, vector<int>(n));
    }
    void add_edge(int u, int v){
        G[u].push_back(v);
        G[v].push_back(u);
    }
    void build(int root = 0){
        dfs(root, -1, 0, G);
        for(int i = 0; i < 40; i++){
            for(int j = 0; j < N; j++){
                if(parent[i][j] == -1) parent[i + 1][j] = -1;
                else parent[i + 1][j] = parent[i][parent[i][j]];
            }
        }
    }
    int lca(int v, int u){//lcaを求める
        if(depth[v] < depth[u]) swap(v, u);
        for(int k = 0; k < 41; k++){
            if((depth[v] - depth[u]) >> k & 1) v = parent[k][v];
        }
        if(v == u) return u;
        for(int k = 40; k >= 0; k--){
            if(parent[k][u] != parent[k][v]){
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }
private:
    void dfs(int v, int par, int d, vector<vector<int>>&G){
        parent[0][v] = par;
        depth[v] = d;
        for(int i: G[v]){
            if(i != par) dfs(i, v, d + 1, G);
        }
    }
};
int main(){
    int N, K;
    cin >> N >> K;
    vector<vector<int>> G(N);
    for(int i = 0; i < N - 1; i++){
        int a, b;
        cin >> a >> b;
        a--;
        b--;
        G[a].push_back(b);
        G[b].push_back(a);
    }
    vector<bool> D(N);
    for(int i = 0; i < K; i++) {
        int k;
        cin >> k;
        k--;
        D[k] = true;
    }
    LCA lca(G);
    lca.build();
    int INF = 1000000000;
    int l = 0, r = 0;
    {
        vector<int> d(N, -INF);
        queue<int> q;
        q.push(0);
        d[0] = 0;
        while(!q.empty()){
            int now = q.front();
            q.pop();
            for(int to : G[now]){
                if(d[to] == -INF){
                    q.push(to);
                    d[to] = d[now] + 1;
                }
            }
        }
        int ma = -INF;
        for(int i = 0; i < N; i++){
            if(D[i]){
                if(ma < d[i]) {
                    l = i;
                    ma = d[i];
                }
            }
        }
        q.push(l);
        d.assign(N, -INF);
        d[l] = 0;
        while(!q.empty()){
            int now = q.front();
            q.pop();
            for(int to : G[now]){
                if(d[to] == -INF){
                    q.push(to);
                    d[to] = d[now] + 1;
                }
            }
        }
        ma = -INF;
        for(int i = 0; i < N; i++){
            if(D[i]){
                if(ma < d[i]) {
                    r = i;
                    ma = d[i];
                }
            }
        }
    }
    vector<int> d(N, INF);
    queue<int> q;
    q.push(0);
    d[0] = 0;
    while(!q.empty()){
        int now = q.front();
        q.pop();
        for(int to: G[now]){
            if(d[to] == INF){
                d[to] = d[now] + 1;
                q.push(to);
            }
        }
    }
    vector<int> cnt(N);
    int sum = 0;
    auto dfs = [&](auto dfs, int now, int par = -1)->bool{
        bool f = false;
        for(int to : G[now]){
            if(to != par){
                f = dfs(dfs, to, now);
                cnt[now] += cnt[to];
            }
        }
        if(D[now]) {
            f = true;
            cnt[now]++;
        }
        if(f) sum += 2;
        return f;
    };
    dfs(dfs, 0);
    vector<int> ans(N);
    sum -= 2;
    auto dfs2 = [&](auto dfs2, int now, int s, int par = -1) -> void{
        for(int to : G[now]){
            if(to != par){
                if(cnt[to] == N) dfs2(dfs2, to, s - 2, now);
                else if(cnt[to] == 0) dfs2(dfs2, to, s + 2, now);
                else dfs2(dfs2, to, s, now);
            }
        }
        int tl = lca.lca(l, now), tr = lca.lca(r, now);
        int dl = d[now] + d[l] - 2 * d[tl], dr = d[now] + d[r] - 2 * d[tr];
        ans[now] = s - max(dl, dr);
    };
    dfs2(dfs2, 0, sum);
    for(int i = 0; i < N; i++){
        cout << ans[i] << endl;
    }
}