#pragma GCC optimize("Ofast","inline")
#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N=2e6+50;

namespace IO {
#define iL (1 << 20)
char ibuf[iL], *iS = ibuf + iL, *iT = ibuf + iL;
#define gc() ((iS == iT) ? (iT = (iS = ibuf) + fread(ibuf, 1, iL, stdin), iS == iT ? EOF : *iS ++) : *iS ++)
template<class T> inline void read(T &x) {
  x = 0;int f = 0;char ch = gc();
  for (; !isdigit(ch); f |= ch == '-', ch = gc());
  for (; isdigit(ch); x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc());
  x = (f == 1 ? ~ x + 1 : x);
}
template<class T, class... Args> inline void read(T &x, Args&... args) { read(x), read(args...); }
template<class T> inline void readch(T &x) { char ch = gc(); for (; !isalpha(ch); ch = gc()); x = ch; }
char Out[iL], *iter = Out;
#define flush() fwrite(Out, 1, iter - Out, stdout), iter = Out
template<class T> inline void write(T x, char ch = '\n') {
  T l, c[35];
  if (x < 0) *iter ++ = '-', x = ~ x + 1;
  for (l = 0; !l || x; c[l] = x % 10, l++, x /= 10);
  for (; l; -- l, *iter ++ = c[l] + '0');*iter ++ = ch;
  flush();
}
template<class T, class... Args> inline void write(T x, Args... args) { write(x, ' '), write(args...); }
} // IO
using namespace IO;

struct node
{
    int u,v,nxt;
}e[N];

int n,las,cnt,head[N],val[N],top[N],siz[N],son[N],dep[N],fa[N],p[N],cc,dfn[N],st[N>>1][20],q,lg[N],m,t[N];

void dfs1(int x,int f)
{
    fa[x]=f;dep[x]=dep[f]+1;siz[x]=1;
    for(int i=head[x];i;i=e[i].nxt)if(e[i].v!=f)
    {
        int v=e[i].v;
        dfs1(v,x);siz[x]+=siz[v];
        if(siz[v]>siz[son[x]])son[x]=v;
    }
}

void dfs2(int x,int topp)
{
    top[x]=topp;dfn[x]=++cc;p[cc]=x;
    if(!son[x])return;dfs2(son[x],topp);
    for(int i=head[x];i;i=e[i].nxt)
    {
        int v=e[i].v;
        if(v==son[x]||v==fa[x])continue;
        dfs2(v,v);
    }
}

struct poi
{
    int l,r,w,pos;

    friend bool operator<(poi a,poi b)
    {
        return a.w<b.w;
    }
};

int chk(int a,int b)
{
    return val[p[a]]>val[p[b]]?a:b;
}

poi find(int l,int r)
{
    int k=lg[r-l+1]-1,u=chk(st[l][k],st[r-(1<<k)+1][k]);
    return (poi){l,r,val[p[u]],u};
}

priority_queue<poi>w;

void spl(poi x)
{
    if(x.pos>x.l)w.push(find(x.l,x.pos-1));
    if(x.pos<x.r)w.push(find(x.pos+1,x.r));
}

int fdw()
{
    if(w.empty())return 0;
    poi now=w.top();w.pop();spl(now);
    return now.w;
}

int cmp(int a,int b)
{
    return a>b;
}

void solve(int u,int v)
{
    int num=62*m,nd=0;
    while(top[u]!=top[v])
    {
        if(dep[top[u]]<dep[top[v]])swap(u,v);
        w.push((poi){find(dfn[top[u]],dfn[u])});
        u=fa[top[u]];
    }
    if(dep[u]<dep[v])swap(u,v);w.push((poi){find(dfn[v],dfn[u])});
    int ty=0;
    for(int i=62;i>=0;i--)
    {
        int f=0;
        for(int j=1;j<=m;j++)
        {
            if(!ty)t[j]=fdw();
            if(!(t[j]&(1ll<<i)))
            {
                for(int k=1;k<=j;k++)w.push((poi){1,1,t[k]-(1ll<<i)*(k<j),1});
                f=2;ty=0;break;
            }
            if((t[j]^nd)&nd){f=1;break;}
        }
        if(f==1)break;
        if(f==2)continue;
        nd|=(1ll<<i),ty=1;
    }
    write(las=nd);
    while(!w.empty())w.pop();
}

main()
{
    read(n);
    for(int i=1;i<n;i++)
    {
        int u,v;read(u,v);
        e[++cnt]=(node){u,v,head[u]};head[u]=cnt;
        e[++cnt]=(node){v,u,head[v]};head[v]=cnt;
    }
    for(int i=1;i<=n;i++)read(val[i]),lg[i]=lg[i>>1]+1;
    dfs1(1,1);dfs2(1,1);
    for(int i=1;i<=n;i++)st[i][0]=i;
    for(int i=1;i<20;i++)
    for(int j=1;j+(1<<i)-1<=n;j++)
    st[j][i]=chk(st[j][i-1],st[j+(1<<i-1)][i-1]);
    read(q);
    while(q--)
    {
        int u,v;read(u,v,m);
        u=((u^las)%n)+1;v=((v^las)%n)+1;
        solve(u,v);
    }
}