#include <bits/stdc++.h>
#include <random>

#define MP make_pair
#define pb push_back
#define ls(x) (x << 1)
#define rs(x) (x << 1 | 1)

using namespace std;
using LL = long long;
using ULL = unsigned long long;

const int maxn = 4e5 + 5;
const int maxk = 22;

int n;
int A[maxn];
int dep[maxn];
int fa[maxn][maxk];
vector<int> E[maxn];

struct linear_base{
    int base[maxk];
    int dep[maxk];

    void insert(int x, int d){
        for(int i = maxk - 1; i >= 0; --i){
            int b = ((x >> i) & 1);
            if(b){
                if(!base[i]){
                    base[i] = x;
                    dep[i] = d;
                    return;
                }
                else{
                    if(dep[i] < d){
                        swap(dep[i], d);
                        swap(base[i], x);
                    }
                }
                x ^= base[i];
            }
        }
    }

    void operator = (const linear_base &rhs){
        for(int i = 0; i < maxk; ++i){
            base[i] = rhs.base[i];
            dep[i] = rhs.dep[i];
        }
    }

    int query(int x, int d){
        for(int i = maxk - 1; i >= 0; --i){
            int b = ((x >> i) & 1);
            if(b && dep[i] >= d) 
                x ^= base[i];
        }
        return (x == 0);
    }

}B[maxn], tmp_base;

void merge(linear_base &a, linear_base &b)
{
    tmp_base = a;
    for(int i = 0; i < maxk; ++i){
        tmp_base.insert(b.base[i], b.dep[i]);
    }
}

void dfs(int x, int fr)
{
    B[x] = B[fr];
    B[x].insert(A[x], dep[x]);
    for(auto &v : E[x]){
        if(v == fr) continue;
        dep[v] = dep[x] + 1;
        fa[v][0] = x;
        dfs(v, x);
    }

    
}

int lca(int x, int y)
{
    if(dep[x] < dep[y])  swap(x, y);
    int d = dep[x] - dep[y];
    for(int i = maxk - i; i >= 0; --i){
        if(((d >> i) & 1)){
            x = fa[x][i];
        }
    }
    if(x == y)  return x;
    for(int i = maxk - 1; i >= 0; --i){
        if(fa[x][i] != fa[y][i]){
            x = fa[x][i], y = fa[y][i];
        }
    }
    return x == y ? x : fa[x][0];
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

    cin >> n;
    for(int i = 1; i <= n; ++i){
        cin >> A[i];
    }
    for(int i = 1; i <= n - 1; ++i){
        int a, b;
        cin >> a >> b;
        E[a].pb(b), E[b].pb(a);
    }

    dfs(1, 0);
    for(int j = 1; j <= maxk - 1; ++j){
        for(int i = 1; i <= n; ++i){
            fa[i][j] = fa[fa[i][j - 1]][j - 1];
        }
    }

    int Q = 0;
    cin >> Q;
    while(Q--){
        int a, b, c;
        cin >> a >> b >> c;
        merge(B[a], B[b]);
        int l = lca(a, b);
        int ans = tmp_base.query(c, dep[l]);
        if(ans) cout << "YES\n";
        else cout << "NO\n";
    }

	return 0;
}

#include <bits/stdc++.h>

#define pb emplace_back

using namespace std;
typedef long long LL;

const int maxn = 1e6 + 5;
const int INF = 1e9 + 7;

LL *now;
LL *F[maxn];
LL buf[maxn << 1];


int n;
vector<int> E[maxn];
int A[maxn], mi[maxn][21];
int son[maxn], dep[maxn], mx[maxn];
int lg[maxn];

template<typename T>
void read(T &x)
{
	x = 0;
	int fl = 1;
	char ch = getchar();
	while(!isdigit(ch) && ch != '-')
		ch = getchar();
	if(ch == '-')
		fl = -1, ch = getchar();
	while(isdigit(ch))
		x = x * 10 + ch - '0', ch = getchar();
	x *= fl;
}

void dfs1(int x, int fr)
{
	for(auto &v : E[x]){
		if(v == fr)
			continue;
		dep[v] = dep[x] + 1;
		dfs1(v, x);
		if(mx[v] > mx[son[x]])
			son[x] = v;
		mx[x] = max(mx[x], mx[v]);
	}
	mx[x] += 1;
}

int ask(int l, int r)
{
	int t = lg[r - l + 1];
	return min(mi[l][t], mi[r - (1 << t) + 1][t]);
}

void dp(int x, int fr)
{
	F[x][0] = A[0];
	if(son[x]){
		F[son[x]] = F[x] + 1;
		dp(son[x], x);
	}

	int _mx = 0;
	for(auto &v : E[x]){
		if(v == fr || v == son[x])
			continue;
		F[v] = now;
		now += mx[v];
		_mx = max(_mx, mx[v] + 1);
		dp(v, x);
		for(int j = 0; j < mx[v]; ++j){
			F[x][j + 1] += F[v][j]; 
		}
			
	}
	for(int j = 0; j <= _mx; ++j)
		F[x][j] = min(F[x][j], 1LL * ask(j, dep[x] + j));
}

int main()
{
	int T;
	read(T);
	while(T--){
		read(n);		
		for(int i = 0; i <= now - buf; ++i)
			buf[i] = 0;
		for(int i = 2; i <= n; ++i)
			lg[i] = lg[i >> 1] + 1;
		for(int i = 1; i <= n; ++i)
			E[i].clear(), son[i] = dep[i] = mx[i] = 0;
		for(int i = 0; i <= n - 1; ++i){
			read(A[i]);
			mi[i][0] = A[i];
		}

		for(int j = 1; j <= lg[n]; ++j)
			for(int i = 0; i + (1 << j) - 1 <= n - 1; ++i)
				mi[i][j] = min(mi[i][j - 1], mi[i + (1 << (j - 1))][j - 1]);

		for(int i = 1; i <= n - 1; ++i){
			int u, v;
			read(u), read(v);
			E[u].pb(v), E[v].pb(u);
		}

		dfs1(1, 0);


		now = buf;
		F[1] = now;
		now += mx[1];
		dp(1, 0);

		LL ans = 0;
		for(int i = 0; i < mx[1]; ++i)
			ans += F[1][i];
		cout << ans << endl;
	}
}

for(int i=1;i<=n;++i){
    while(tp&&A[stk[tp]]>A[i])
    	L[i]=stk[tp--];
    if(tp)
    	R[stk[tp]]=i;
    stk[++tp]=i;
}