#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<chrono>
#define pc(x) (*oo++=(x),oo==ouf+(1<<22)?fwrite(oo=ouf,1,1<<22,stdout):0)
char ouf[1<<22],*oo{ouf};
inline void write(const char &c) {
    pc(c);
}
inline void write(const char *const s) {
    for(const char *i=s;*i;i++) {
        pc(*i);
    }
}
template<typename Tp>
inline void write(Tp x) {
    if(x==0) {
        return pc('0'),void();
    }
    static char dig[17]{};
    char *ptr(dig);
    while(x) {
        *ptr++=x%10^48,x/=10;
    }
    while(ptr!=dig) {
        pc(*--ptr);
    }
}
template<typename Tp,typename... Tps>
inline void write(Tp x,Tps... xs) {
    write(x),write(xs...);
}
inline void flush() {
    fwrite(ouf,1,oo-ouf,stdout),oo=ouf;
    fflush(stdout);
}
#undef pc
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef __uint128_t ulll;
constexpr int N{200000};
struct edge {
    int v,next;
};
edge e[(N<<1)+5];
int en,last[N+5];
inline void clear(const int &n) {
    std::fill(last+1,last+n+1,0),en=0;
}
inline void add_edge(const int &u,const int &v) {
    e[++en]={v,last[u]},last[u]=en;
    e[++en]={u,last[v]},last[v]=en;
}
uint cx,cy,mod;
uint len;ull mul;
inline void init() {
    len=32-__builtin_clz(mod-1);
    mul=((ulll(1)<<len+63)-1)/mod+1;
}
inline ull divide(const ull &x) {
    return ulll(x)*mul>>len+63;
}
inline uint reduce(const ull &x) {
    return uint(x)-mod*divide(x);
}
inline uint square(const uint &x) {
    return reduce(ull(x)*x);
}
inline uint calc(const uint &x,const uint &y) {
    return reduce(ull(cx)*x+ull(cy)*square(y));
}
int l[N+5],r[N+5];
int fa[N+5];
struct node {
    ll v0,v1;
    constexpr node &operator+=(const node &x) {
        return this->v0+=x.v0,this->v1+=x.v1,*this;
    }
    constexpr node operator+(const node &x) const {
        return node{this->v0+x.v0,this->v1+x.v1};
    }
    constexpr node &operator-=(const node &x) {
        return this->v0-=x.v0,this->v1-=x.v1,*this;
    }
    constexpr node &operator*=(const int &x) {
        ll tmp{this->v0};
        this->v0=std::max(tmp,this->v1+x);
        this->v1=tmp;
        return *this;
    }
    constexpr node operator*(const int &x) const {
        return node{std::max(this->v0,this->v1+x),this->v0};
    }
    constexpr ll operator*() const {
        return v0;
    }
};
node sum1[N+5],dp1[N+5],dp2[N+5];
void dfs1(const int &u) {
    sum1[u]=dp2[u]={};
    for(int i=last[u];i;i=e[i].next) {
        int &v{e[i].v};
        if(v==fa[u]) {
            continue;
        }
        fa[v]=u,dfs1(v);
        sum1[u]+=dp1[v];
        dp2[u]+=dp2[v];
    }
    (dp1[u]=sum1[u])*=l[u],dp2[u]*=r[u];
}
struct line {
    int id;
    uint val;
    int base;
    ll vl,vr;
};
line stk[N+5];
int top;
uint sum;
node dp3[N+5];
void dfs2(const int &u) {
    node tmp{dp3[u]+sum1[u]};
    for(int i=last[u];i;i=e[i].next) {
        int &v{e[i].v};
        if(v==fa[u]) {
            continue;
        }
        tmp-=dp1[v];
        dp3[v]=tmp*l[u];
        dfs2(v);
        tmp+=dp2[v];
    }
    sum^=calc(u,l[u]);
    stk[++top]={u,sum,int(std::max<ll>(l[u],std::min<ll>(r[u],tmp.v0-tmp.v1))),*(tmp*l[u]),*(tmp*r[u])};
    sum^=calc(u,r[u]);
}
ll val[N+5];
int ans[N+5];
int arr[N+5];
void solve() {
    int n,q;
    scanf("%d%d",&n,&q);
    clear(n);
    scanf("%u%u%u",&cx,&cy,&mod);
    init();
    for(int i=1;i<n;i++) {
        int u,v;
        scanf("%d%d",&u,&v);
        add_edge(u,v);
    }
    for(int i=1;i<=n;i++) {
        scanf("%d%d",l+i,r+i);
    }
    std::fill(fa+1,fa+n+1,0);
    dfs1(1);
    stk[top=0]={},dp3[1]={};
    sum=0;
    for(int i=1;i<=n;i++) {
        sum^=calc(i,l[i]);
    }
    dfs2(1);
    for(int i=1;i<=q;i++) {
        scanf("%lld",val+i);
        if(val[i]<stk[1].vl||val[i]>stk[top].vr) {
            ans[i]=-1,write("-1",i==q?'\n':' ');
            continue;
        }
        int l{1},r{top-1};
        while(l<=r) {
            int mid{l+r>>1};
            if(stk[mid].vr>=val[i]) {
                r=mid-1;
            }
            else {
                l=mid+1;
            }
        }
        ans[i]=l;
        write(stk[l].val^calc(stk[l].id,stk[l].base+val[i]-stk[l].vl),i==q?'\n':' ');
    }
    flush();
#ifdef ONLINE_JUDGE
    for(int x;scanf("%d",&x)==1&&x!=0;) {
#else
    int c;
    scanf("%d",&c);
    while(c--) {
        int x;
        scanf("%d",&x);
#endif
        if(ans[x]==-1) {
            puts("-1"),fflush(stdout);
            continue;
        }
        int &y{ans[x]};
        for(int i=1;i<y;i++) {
            arr[stk[i].id]=r[stk[i].id];
        }
        arr[stk[y].id]=stk[y].base+val[x]-stk[y].vl;
        for(int i=y+1;i<=top;i++) {
            arr[stk[i].id]=l[stk[i].id];
        }
        for(int i=1;i<=n;i++) {
            write(arr[i],i==n?'\n':' ');
        }
        flush();
    }
}
int main() {
#ifndef ONLINE_JUDGE
    auto t0{std::chrono::high_resolution_clock::now()};
    freopen("19","r",stdin);
    freopen("0.out","w",stdout);
#endif
    int t;
    scanf("%d",&t);
    while(t--) {
        solve();
    }
#ifndef ONLINE_JUDGE
    auto t1{std::chrono::high_resolution_clock::now()};
    std::cerr<<"timer: "<<std::chrono::duration_cast<std::chrono::milliseconds>(t1-t0)<<'\n';
#endif
    return 0;
}