#include<bits/stdc++.h>
using namespace std;

#define rep(i,n) for(int i=0;i<n;i++)
#define Rep(i,sta,n) for(int i=sta;i<n;i++)

typedef pair<int,int> P;
struct graph{

    vector<P> ade;

    vector<int> ids;
    map<int,int> mp;
    vector<int> par;
    int ans=0;
    vector<bool> isc;


    void add_v(int x){
        if(mp.find(x)==mp.end()){
            par.push_back(par.size());
            isc.push_back(false);
            mp[x]=ids.size();
            ids.push_back(x);
        }
    }
    int find(int x){
        if(par[x]==x)return x;
        else return par[x]=find(par[x]);
    }
    void add_e(int x,int y){
        add_v(x);add_v(y);
        x=mp[x];x=find(x);
        y=mp[y];y=find(y);
        if(x==y){
            if(!isc[x]){
                ade.push_back({ids[x],ids[x]});
                ans++;isc[x]=true;
            }

        }
        else{
            if(isc[x]&&isc[y])return;
            par[x]=y;
            if(isc[x])isc[y]=true;
            ans++;
            ade.push_back({ids[x],ids[y]});
        }
    }
    int query(){
        return ans;
    }
};

void merge(graph &a,graph &b){
    if(a.ade.size()<b.ade.size())swap(a,b);
    rep(j,b.ade.size()){
        int l=b.ade[j].first;
        int r=b.ade[j].second;
        a.add_e(l,r);

    }

}
vector<P> es;


int ans[1<<17];

int n;
vector<int> G[1<<17];
int c[1<<17],d[1<<17];

int depth[1<<17];
void ddfs(int id,int fr){
    depth[id]=1;
    rep(j,G[id].size()){
        int to=G[id][j];
        if(to==fr)continue;
        ddfs(to,id);
        depth[id]+=depth[to];
    }
}

void sdfs(int id,int fr){
    es.push_back({c[id],d[id]});
    rep(j,G[id].size()){
        int to=G[id][j];
        if(to==fr)continue;
        sdfs(to,id);
    }
}

graph dfs(int id,int fr){
    graph g;
    g.add_e(c[id],d[id]);
    rep(j,G[id].size()){
        int to=G[id][j];
        if(to==fr)continue;
        graph nex=dfs(to,id);
        merge(g,nex);
    }
    ans[id]=g.query();
    return g;
}
void solve(){
    int n,k;cin>>n>>k;
    rep(i,n-1){
        int u,v;cin>>u>>v;u--;v--;
        G[u].push_back(v);
        G[v].push_back(u);
    }
    rep(i,n){
        cin>>c[i]>>d[i];
        c[i]--;d[i]--;
    }
    ddfs(0,-1);
    dfs(0,-1);
    rep(i,n)cout<<ans[i]<<endl;

}
int main(){
    solve();
    return 0;
}
