/*input
15 15
1 2
1 2
2 1
2 2
2 1
1 1
1 1
2 2
1 2
2 2
1 3
2 2
1 3
2 1
1 3

2 1
3 1
4 2
5 4
6 5
7 1
8 4
9 7
10 6
11 9
12 3
13 10
14 13
15 13

15 6
4 7
15 5
7 5
7 12
13 6
14 15
15 6
9 8
15 9
4 10
15 13
2 9
12 7
12 3

*/
#include<bits/stdc++.h>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> indexed_set;
//#pragma GCC target("avx2")
//order_of_key #of elements less than x
// find_by_order kth element
using ll=long long;
using ld=long double;
using pii=pair<int,int>;
#define f first
#define s second
#define pb push_back
#define REP(i,n) for(int i=0;i<n;i++)
#define REP1(i,n) for(int i=1;i<=n;i++)
#define FILL(n,x) memset(n,x,sizeof(n))
#define ALL(_a) _a.begin(),_a.end()
#define sz(x) (int)x.size()
#define SORT_UNIQUE(c) (sort(c.begin(),c.end()),c.resize(distance(c.begin(),unique(c.begin(),c.end()))))
const ll maxn=5e5+5;
const ll maxlg=__lg(maxn)+2;
const ll INF64=4e18;
const int INF=0x3f3f3f3f;
const int MOD=998244353;
const ld PI=acos(-1);
const ld eps=1e-4;
#define lowb(x) x&(-x)
#define MNTO(x,y) x=min(x,(__typeof__(x))y)
#define MXTO(x,y) x=max(x,(__typeof__(x))y)
template<typename T1,typename T2>
ostream& operator<<(ostream& out,pair<T1,T2> P){
    out<<P.f<<' '<<P.s;
    return out;
}
template<typename T>
ostream& operator<<(ostream& out,vector<T> V){
    REP(i,sz(V)) out<<V[i]<<((i!=sz(V)-1)?" ":"");
    return out;
}
ll mult(ll a,ll b){
    return a*b%MOD;
}
ll mypow(ll a,ll b){
    a%=MOD;
    if(a==0) return 0;
    if(b<=0) return 1;
    ll res=1LL;  
    while(b){
        if(b&1) res=(res*a)%MOD;
        a=(a*a)%MOD;
        b>>=1;
    }
    return res;
}
struct IO{
    static const int S=1<<21;
    char buf[S],*p1,*p2;int st[105],Top;
    ~IO(){clear();}
    inline void clear(){fwrite(buf,1,Top,stdout);Top=0;}
    inline void pc(const char c){Top==S&&(clear(),0);buf[Top++]=c;}
    inline char gc(){return p1==p2&&(p2=(p1=buf)+fread(buf,1,1<<21,stdin),p1==p2)?EOF:*p1++;}
    inline IO&operator >> (char&x){while(x=gc(),x==' '||x=='\n'||x=='\r');return *this;}
    template<typename T>inline IO&operator >> (T&x){
        x=0;bool f=0;char ch=gc();
       while(!isdigit(ch)){if(ch=='-') f^=1;ch=gc();}
        while(isdigit(ch)) x=(x<<3)+(x<<1)+ch-'0',ch=gc();
        f?x=-x:0;return *this;
    }
    inline IO&operator << (const char c){pc(c);return *this;}
    template<typename T>inline IO&operator << (T x){
        if(x<0) pc('-'),x=-x;
        do{st[++st[0]]=x%10,x/=10;}while(x);
        while(st[0]) pc('0'+st[st[0]--]);return *this;
    }
}fin,fout;
vector<int> key[maxn],tr[maxn];
int dep[maxn];
int dist[maxn];
int par[maxn][20];
vector<int> v[maxn];
int in[maxn],out[maxn];;
int cur=0;
void dfs(int u,int p){
    par[u][0]=p;
    in[u]=cur++;
    for(int x:v[u]){
        if(x==p) continue;
        dep[x]=dep[u]+1;
        dist[x]+=dist[u];
        dfs(x,u);
    }
    out[u]=cur-1;
}
void sparse(int n){
    REP1(j,19){
        REP(i,n){
            if(par[i][j-1]!=-1){
                par[i][j]=par[par[i][j-1]][j-1];
            }
            else par[i][j]=-1;
        }
    }
}
int kth(int u,int k){
    while(k){
        u=par[u][__lg(lowb(k))];
        k-=lowb(k);
    }
    return u;
}
int lca(int a,int b){
    if(dep[a]<dep[b]) swap(a,b);
    int d=dep[a]-dep[b];
    while(d){
        a=par[a][__lg(lowb(d))];
        d-=lowb(d);
    }
    if(a==b) return a;
    for(int j=19;j>=0;j--){
        if(par[a][j]!=par[b][j]){
            a=par[a][j],b=par[b][j];
        }
    }
    return par[a][0];
}
bool cmp(int a,int b){
    return in[a]<in[b];
}
vector<pii> build(vector<int> sp){
    sort(ALL(sp),cmp);
    vector<int> stk;
    vector<pii> ed;
    stk.pb(0);
    for(int x:sp){
        if(!x) continue;
        int z=lca(x,stk.back());
        if(z!=stk.back()){
            while(sz(stk)>=2 and in[z]<in[stk[sz(stk)-2]]){
                ed.pb({stk[sz(stk)-2],stk.back()});
                stk.pop_back();
            }
            ed.pb({z,stk.back()});
            if(in[z]>in[stk[sz(stk)-2]]){
                 stk[sz(stk)-1]=z;
            }
            else{
                stk.pop_back();
            }
        }
        stk.pb(x);
    }
    REP(i,sz(stk)-1) ed.pb({stk[i],stk[i+1]});
    return ed;
}
vector<int> g[maxn];
bool tp[maxn];
int col[maxn];
int rt;
vector<pii> pths;
void dfs2(int u,int p,int tot){
    if(tp[u] and col[u]==col[rt]){
        --tot;
    }
    if(tot<0){
        pths.pb({rt,u});
        return;
    }
    for(int x:g[u]){
        if(x==p) continue;
        dfs2(x,u,tot+(!tp[x] and col[x]==col[rt]));
    }
}
vector<pair<int,pii>> vv[maxn];
vector<pii> qq[maxn];
inline void add(int a,int b,int c,int d,int x){
    vv[a].pb({x,{c,d}});
    vv[b+1].pb({-x,{c,d}});
}
int bit[maxn];
inline void upd(int x,int v){
    ++x;
    while(x<maxn){
        bit[x]+=v;
        x+=lowb(x);
    }
}
inline int query(int x){
    ++x;
    int ans=0;
    while(x){
        ans+=bit[x];
        x-=lowb(x);
    }
    return ans;
}
int ans[maxn*2];
int main(){
    int n,q;
    fin>>n>>q;
    REP(i,n){
        int a,b;
        fin>>a>>b;
        tp[i]=(a-1),col[i]=b;
        if(a==1) key[b].pb(i);
        else tr[b].pb(i);
    }
    REP(i,n-1){
        int a,b;
        fin>>a>>b;
        --a,--b;
        v[a].pb(b),v[b].pb(a);
    }
    dfs(0,-1);
    sparse(n);
    REP(i,n){
        vector<int> sp;
        for(int x:key[i]) sp.pb(x);
        for(int x:tr[i]) sp.pb(x);
        if(!sz(sp)) continue;
        auto ed=build(sp);
        for(auto x:ed){
            g[x.f].pb(x.s),g[x.s].pb(x.f);
        }
        for(int x:key[i]){
            rt=x;
            dfs2(x,-1,0);
        }
        for(auto x:ed) g[x.f].clear(),g[x.s].clear();
    }
    for(auto x:pths){
        //cout<<x<<'\n';
        int z=lca(x.f,x.s);
        if(z==x.f){
            int z=kth(x.s,dep[x.s]-dep[x.f]-1);
            add(0,n-1,in[x.s],out[x.s],1);
            add(in[z],out[z],in[x.s],out[x.s],-1);
        }
        else if(z==x.s){
            int z=kth(x.f,dep[x.f]-dep[x.s]-1);
            add(in[x.f],out[x.f],0,n-1,1);
            add(in[x.f],out[x.f],in[z],out[z],-1);
        }
        else{
            add(in[x.f],out[x.f],in[x.s],out[x.s],1);
        }
    }
    REP(i,q){
        int a,b;
        fin>>a>>b;
        --a,--b;
        qq[in[a]].pb({in[b],i});
    }
    int p=0;
    REP(i,n){
        for(auto x:vv[i]){
            upd(x.s.f,x.f);
            upd(x.s.s+1,-x.f);
        }
        for(auto x:qq[i]){
            ans[x.s]=query(x.f);
        }
    }
    REP(i,q) fout<<ans[i],fout.pc('\n');
}