// 那就是希望。
// 即便需要取模，也是光明。

#include <algorithm>
#include <stdio.h>
#include <vector>
typedef long long llt;
typedef unsigned uint;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _max(T&a,T b){return(a<b)?a=b,true:false;}
template<typename T>bol _min(T&a,T b){return(b<a)?a=b,true:false;}
template<typename T>T lowbit(T n){return n&-n;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T lcm(T a,T b){return(a!=0||b!=0)?a/gcd(a,b)*b:(T)0;}
template<typename T>T exgcd(T a,T b,T&x,T&y){if(b!=0){T ans=exgcd(b,a%b,y,x);y-=a/b*x;return ans;}else return y=0,x=1,a;}
template<typename T>T power(T base,T index,T mod)
{
    T ans=1%mod;
    while(index)
    {
        if(index&1)ans=ans*base%mod;
        base=base*base%mod,index>>=1;
    }
    return ans;
}
namespace ConstMod
{
    template<const ullt p>
    class mod_ullt
    {
        private:
            ullt v;
            inline ullt chg(ullt w){return(w<p)?w:w-p;}
            inline mod_ullt _chg(ullt w){mod_ullt ans;ans.v=(w<p)?w:w-p;return ans;}
        public:
            mod_ullt():v(0){}
            mod_ullt(ullt v):v(v%p){}
            bol empty(){return!v;}
            inline ullt val(){return v;}
            friend bol operator<(mod_ullt a,mod_ullt b){return a.v<b.v;}
            friend bol operator>(mod_ullt a,mod_ullt b){return a.v>b.v;}
            friend bol operator<=(mod_ullt a,mod_ullt b){return a.v<=b.v;}
            friend bol operator>=(mod_ullt a,mod_ullt b){return a.v>=b.v;}
            friend bol operator==(mod_ullt a,mod_ullt b){return a.v==b.v;}
            friend bol operator!=(mod_ullt a,mod_ullt b){return a.v!=b.v;}
            inline friend mod_ullt operator+(mod_ullt a,mod_ullt b){return a._chg(a.v+b.v);}
            inline friend mod_ullt operator-(mod_ullt a,mod_ullt b){return a._chg(a.v+a.chg(p-b.v));}
            inline friend mod_ullt operator*(mod_ullt a,mod_ullt b){return a.v*b.v;}
            friend mod_ullt operator/(mod_ullt a,mod_ullt b){return b._power(p-2)*a.v;}
            friend mod_ullt operator^(mod_ullt a,ullt b){return a._power(b);}
            inline mod_ullt operator-(){return _chg(p-v);}
            mod_ullt sqrt()
            {
                if(power(v,(p-1)>>1,p)!=1)return 0;
                mod_ullt b=1;do b++;while(b._power((p-1)>>1)==1);
                ullt t=p-1,s=0,k=1;while(!(t&1))s++,t>>=1;
                mod_ullt x=_power((t+1)>>1),e=_power(t);
                while(k<s)
                {
                    if(e._power(1llu<<(s-k-1))!=1)x*=b._power((1llu<<(k-1))*t);
                    e=_power(p-2)*x*x,k++;
                }
                return _min(x,-x),x;
            }
            mod_ullt inv(){return _power(p-2);}
            mod_ullt _power(ullt index){mod_ullt ans(1),w(v);while(index){if(index&1)ans*=w;w*=w,index>>=1;}return ans;}
            voi read(){v=0;chr c;do c=getchar();while(c>'9'||c<'0');do v=(c-'0'+v*10)%p,c=getchar();while(c>='0'&&c<='9');v%=p;}
            voi print()
            {
                static chr C[20];uint tp=0;
                ullt w=v;do C[tp++]=w%10+'0',w/=10;while(w);
                while(tp--)putchar(C[tp]);
            }
            voi println(){print(),putchar('\n');}
            mod_ullt operator++(int){mod_ullt ans=*this;return v=chg(v+1),ans;}
        public:
            inline ullt&operator()(){return v;}
            inline mod_ullt&operator+=(mod_ullt b){return*this=_chg(v+b.v);}
            inline mod_ullt&operator-=(mod_ullt b){return*this=_chg(v+chg(p-b.v));}
            inline mod_ullt&operator*=(mod_ullt b){return*this=v*b.v;}
            mod_ullt&operator^=(ullt b){return*this=_power(b);}
            mod_ullt&operator/=(mod_ullt b){return*this=b._power(p-2)*v;}
            mod_ullt&operator++(){return v=chg(v+1),*this;}
    };
}
// Heaven and Earth... My guiding star...
const ullt Mod=1e9+7;
typedef ConstMod::mod_ullt<Mod>modint;
typedef std::vector<modint>modvec;
std::vector<uint>Way[100005],P[100005];
uint Siz[100005],Dep[100005],Heavy[100005],Fath[100005],Rot[100005];
uint Dfn[100005],End[100005],Back[100005];
modint Dp[100005],DpF[100005],W[100005],Mul[100005],S[100005],SLeft[100005];uint Cnt[100005];
voi dfs1(uint p,uint f)
{
    Fath[p]=f,Siz[p]=1,Heavy[p]=-1,Dp[p]=1;
    for(auto s:Way[p])if(s!=f)
    {
        Dep[s]=Dep[p]+1,dfs1(s,p),Siz[p]+=Siz[s],Dp[p]*=Dp[s]+1,SLeft[p]+=S[s];
        if(!~Heavy[p]||Siz[Heavy[p]]<Siz[s])Heavy[p]=s;
    }
    S[p]=SLeft[p]+Dp[p];if(~Heavy[p])SLeft[p]-=S[Heavy[p]];
}
voi dfs2(uint p,uint r)
{
    static uint cnt=0;
    Rot[p]=r,Back[Dfn[p]=cnt++]=p,W[p]=Mul[p]=1;
    for(auto s:Way[p]){modint w=((s==Fath[p])?DpF[p]:Dp[s])+1;if(w())Mul[p]*=w;else Cnt[p]++;}
    if(~Heavy[p])
    {
        for(auto s:Way[p])if(s!=Fath[p])DpF[s]=Cnt[p]?(Cnt[p]>1?0:((Dp[s]+1)()?0:Mul[p])):Mul[p]/(Dp[s]+1);
        dfs2(Heavy[p],r);for(auto s:Way[p])if(s!=Fath[p]&&s!=Heavy[p])dfs2(s,s),W[p]*=Dp[s]+1;
    }
    End[p]=cnt;
}
uint lca(uint u,uint v)
{
    while(Rot[u]!=Rot[v])
    {
        if(Dep[Rot[u]]<Dep[Rot[v]])std::swap(u,v);
        u=Fath[Rot[u]];
    }
    return Dep[u]<Dep[v]?u:v;
}
std::pair<modint,uint>PreSum[100005];
modint PreAll[100005],SufAll[100005],SumSLeft[100005];
uint Op[55],n0,n1,n2;bol G[55];
uint U[55],V[55];modint Wg[2][55],Wc[55],Wp[55];
std::vector<uint>E[55],Q;
modint We[55],Wne[55],ans;
uint F[55],R[55],c0,c1,c2;
uint getsiz(uint p,uint f)
{
    uint ans=1,s;
    for(auto e:E[p])if(!G[s=U[e]^V[e]^p]&&s!=f)ans+=getsiz(s,p);
    return ans;
}
uint getwp(uint p,uint f,uint siz,uint&w,uint&wp)
{
    uint ans=1,t=0,user,s;
    for(auto e:E[p])if(!G[s=U[e]^V[e]^p]&&s!=f)ans+=user=getwp(s,p,siz,w,wp),_max(t,user);
    _max(t,siz-ans);if(_min(w,t))wp=p;
    return ans;
}
voi dfs(uint p,uint f)
{
    if(~Op[p]){if(!Op[p])c0++;else if(Op[p]==1)c1++;else if(Op[p]==2)c2++;}
    uint s;R[p]=Q.size(),Q.push_back(p),F[p]=f,We[p]=Wp[p];
    for(auto e:E[p])if((s=U[e]^V[e]^p)==f)We[p]*=Wc[e],Wne[p]=Wg[f==V[e]][e];
        else if(!G[s])dfs(s,p);else We[p]*=Wg[p==V[e]][e];
}
voi solve(uint p)
{
    {uint n=getsiz(p,-1);getwp(p,-1,n,n,p);}
    c0=c1=c2=0,Q.clear(),dfs(p,-1);if(c0<n0||c1<n1||c2<n2)return;
    static modint Dp[55][6][6][6];
    for(uint i=0;i<=n0;i++)for(uint j=0;j<=n1;j++)for(uint k=0;k<=n2;k++)Dp[0][i][j][k]=0;
    Dp[0][!Op[p]][Op[p]==1][Op[p]==2]=We[p];
    for(uint c=1;c<Q.size();c++)
    {
        if(!~Op[Q[c]])
        {
            for(uint i=0;i<=n0;i++)for(uint j=0;j<=n1;j++)for(uint k=0;k<=n2;k++)
                Dp[c][i][j][k]=Dp[R[F[Q[c]]]][i][j][k];
        }
        else if(!Op[Q[c]])
        {
            for(uint j=0;j<=n1;j++)for(uint k=0;k<=n2;k++)Dp[c][0][j][k]=0;
            for(uint i=1;i<=n0;i++)for(uint j=0;j<=n1;j++)for(uint k=0;k<=n2;k++)
                Dp[c][i][j][k]=Dp[R[F[Q[c]]]][i-1][j][k];
        }
        else if(Op[Q[c]]==1)
        {
            for(uint i=0;i<=n0;i++)for(uint k=0;k<=n2;k++)Dp[c][i][0][k]=0;
            for(uint i=0;i<=n0;i++)for(uint j=1;j<=n1;j++)for(uint k=0;k<=n2;k++)
                Dp[c][i][j][k]=Dp[R[F[Q[c]]]][i][j-1][k];
        }
        else
        {
            for(uint i=0;i<=n0;i++)for(uint j=0;j<=n1;j++)Dp[c][i][j][0]=0;
            for(uint i=0;i<=n0;i++)for(uint j=0;j<=n1;j++)for(uint k=1;k<=n2;k++)
                Dp[c][i][j][k]=Dp[R[F[Q[c]]]][i][j][k-1];
        }
        for(uint t=Q[c];t!=(c==Q.size()-1?p:F[Q[c+1]]);t=F[t])
            for(uint i=0;i<=n0;i++)for(uint j=0;j<=n1;j++)for(uint k=0;k<=n2;k++)
                Dp[R[F[t]]][i][j][k]=Dp[R[F[t]]][i][j][k]*Wne[t]+Dp[R[t]][i][j][k]*We[t];
    }
    ans+=Dp[0][n0][n1][n2],G[p]=1;for(auto e:E[p])if(!G[U[e]^V[e]^p])solve(U[e]^V[e]^p);
}
namespace Seg
{
    const uint Lim=131072;
    struct Info
    {
        modint mul,pre,suf,sum;
        friend Info operator+(Info a,Info b)
        {
            return{a.mul*b.mul,a.pre+a.mul*b.pre,a.suf*b.mul+b.suf,a.sum+b.sum+a.suf*b.pre};
        }
    };
    Info Val[Lim<<1|1];
    voi build()
    {
        for(uint i=0;i<100000;i++)Val[i|Lim]={W[Back[i]],W[Back[i]],W[Back[i]],W[Back[i]]};
        for(uint i=Lim-1;i;i--)Val[i]=Val[i<<1]+Val[i<<1|1];
    }
    Info find(uint u,uint l,uint r,uint n)
    {
        if(l>=r)return{1,0,0,0};
        if(!l&&r==n)return Val[u];
        if(l<(n>>1))
            if(r<=(n>>1))return find(u<<1,l,r,n>>1);
            else return find(u<<1,l,n>>1,n>>1)+find(u<<1|1,0,r-(n>>1),n>>1);
        else return find(u<<1|1,l-(n>>1),r-(n>>1),n>>1);
    }
    modint query(uint l,uint r){return find(1,l,r,Lim).sum;}
}
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    freopen("QAQ.out","w",stdout);
#endif
    uint n,q;scanf("%u%u",&n,&q);
    for(uint i=0,c;i<n;i++)scanf("%u",&c),P[c-1].push_back(i);
    for(uint i=1,u,v;i<n;i++)scanf("%u%u",&u,&v),Way[--u].push_back(--v),Way[v].push_back(u);
    dfs1(0,-1),dfs2(0,0),PreSum[0]={1,0};
    for(uint i=0;i<n;i++)
        PreSum[i+1]=W[Back[i]]()?std::pair<modint,uint>{PreSum[i].first*W[Back[i]],PreSum[i].second}
                                :std::pair<modint,uint>{PreSum[i].first,PreSum[i].second+1},
        SumSLeft[i+1]=SumSLeft[i]+SLeft[Back[i]],PreAll[i+1]=(PreAll[i]+1)*W[Back[i]];
    SufAll[n]=1;for(uint i=n-1;~i;i--)SufAll[i]=SufAll[i+1]*W[Back[i]]+1;
    Seg::build();
    while(q--)
    {
        static uint Id[100005],C[55],a,b,c;scanf("%u%u%u%u%u%u",&a,&n0,&b,&n1,&c,&n2);
        if(P[--a].size()<n0||P[--b].size()<n1||P[--c].size()<n2){puts("0");continue;}
        Q={0};
        for(auto s:P[a])Q.push_back(s);
        for(auto s:P[b])Q.push_back(s);
        for(auto s:P[c])Q.push_back(s);
        std::sort(Q.begin(),Q.end(),[&](uint a,uint b){return Dfn[a]<Dfn[b];});
        for(uint i=Q.size()-1;i;i--)Q.push_back(lca(Q[i],Q[i-1]));
        std::sort(Q.begin(),Q.end(),[&](uint a,uint b){return Dfn[a]<Dfn[b];});
        Q.erase(std::unique(Q.begin(),Q.end()),Q.end());
        F[0]=-1;for(uint i=0;i<Q.size();i++)Id[Q[i]]=i,Op[i]=-1,G[i]=false;
        for(auto s:P[a])Op[Id[s]]=0;
        for(auto s:P[b])Op[Id[s]]=1;
        for(auto s:P[c])Op[Id[s]]=2;
        for(uint i=0;i<Q.size();i++)E[i].clear(),Wp[i]=Mul[Q[i]],C[i]=Cnt[Q[i]];
        for(uint i=1;i<Q.size();i++)
        {
            uint f=lca(Q[i],Q[i-1]);uint t=Heavy[f];modint mul=1,pre=1,suf=1,w;
            for(uint j=Q[i],l,r;;)
            {
                l=Rot[j]==Rot[f]?Dfn[f]+1:Dfn[Rot[j]],r=Dfn[j];
                w=PreSum[l].second==PreSum[r].second?PreSum[r].first/PreSum[l].first:0,
                pre=pre+mul*(PreAll[r]-PreAll[l]*w),suf=suf*w+(SufAll[l]-SufAll[r]*w),mul*=w;
                if(Rot[j]==Rot[f])break;
                else if(Fath[Rot[j]]==f){t=Rot[j];break;}
                else
                {
                    j=Rot[j];
                    w=Cnt[Fath[j]]?(Cnt[Fath[j]]>1||(Dp[j]+1)())?0:Dp[Fath[j]]:Dp[Fath[j]]/(Dp[j]+1);
                    suf=suf*w+1,pre+=mul*=w;
                    j=Fath[j];
                }
            }
            U[i-1]=i,V[i-1]=Id[f],Wg[0][i-1]=pre,Wg[1][i-1]=suf,Wc[i-1]=mul;
            if((DpF[Q[i]]+1)())Wp[i]/=DpF[Q[i]]+1;else C[i]--;
            if((Dp[t]+1)())Wp[Id[f]]/=Dp[t]+1;else C[Id[f]]--;
            E[i].push_back(i-1),E[Id[f]].push_back(i-1);
        }
        for(uint i=0;i<Q.size();i++)if(C[i])Wp[i]=0;
        ans=0;
        if(!n0&&!n1&&!n2)
        {
            ans+=S[0]-Dp[0];
            for(uint i=1;i<Q.size();i++)
            {
                uint f=lca(Q[i],Q[i-1]);uint t=Heavy[f];modint suf=1,w;
                for(uint j=Q[i],l,r;;)
                {
                    l=Rot[j]==Rot[f]?Dfn[f]+1:Dfn[Rot[j]],r=Dfn[j];
                    w=PreSum[l].second==PreSum[r].second?PreSum[r].first/PreSum[l].first:0,
                    ans+=SumSLeft[r]-SumSLeft[l]+(suf-1)*(PreAll[r]-PreAll[l]*w)+Seg::query(l,r);
                    suf=suf*w+(SufAll[l]-SufAll[r]*w);
                    if(Rot[j]==Rot[f])break;
                    else if(Fath[Rot[j]]==f){t=Rot[j];break;}
                    else
                    {
                        j=Rot[j];
                        w=Mul[Fath[j]];uint c=Cnt[Fath[j]];
                        if((Dp[j]+1)())w/=Dp[j]+1;else c--;
                        if((DpF[Fath[j]]+1)())w/=DpF[Fath[j]]+1;else c--;
                        if(c)w=0;
                        ans+=S[Fath[j]]-Dp[Fath[j]]-S[j]+suf*w,suf=suf*w+1;
                        j=Fath[j];
                    }
                }
                ans+=S[Q[i]]-Dp[Q[i]]-S[t];
            }
        }
        solve(0),ans.println();
    }
    return 0;
}

// 那就是希望。
// 即便需要取模，也是光明。