#include <bits/stdc++.h>
#define int long long
#define id(x) (lower_bound(h + 1, h + 1 + hn, x) - h)
#define N 100005
using namespace std;
int n, m, v[N], fa[N][20], dep[N], root[N], h[N], hn, cnt;
int head[N], to[N << 1], nxt[N << 1], tot;

struct node {
	int l, r, sum;
} tre[N << 6];

inline void read(int &x) {
	char ch = x = 0;
	int m = 1;
	while (ch < '0' || ch > '9') {
		ch = getchar();
		if (ch == '-') m *= -1;
	}
	while (ch >= '0' && ch <= '9') {
		x = (x << 1) + (x << 3) + ch - 48;
		ch = getchar();
	}
	x *= m;
	return ;
}

inline void print(int x) {
	if (x < 0) putchar('-'), x = -x;
	static int stk[50];
	int top = 0;
	do {
		stk[top++] = x % 10;
		x /= 10;
	} while (x);
	while (top) {
		putchar(stk[--top] + 48);
	}
	putchar('\n');
	return ;
}

inline void add(int u, int v) {
	to[tot] = v;
	nxt[tot] = head[u];
	head[u] = tot++;
	return ;
}

inline void pushup(int rt) {
	int l = tre[rt].l, r = tre[rt].r;
	tre[rt].sum = tre[l].sum + tre[r].sum;
	return ;
}

void insert(int &nowrt, int rt, int l, int r, int x) {
	nowrt = ++cnt;
	tre[nowrt] = tre[rt];
	if (l == r) {
		tre[nowrt].sum++;
		return ;
	}
	int mid = (l + r) >> 1;
	if (x <= mid) insert(tre[nowrt].l, tre[rt].l, l, mid, x);
	else insert(tre[nowrt].r, tre[rt].r, mid + 1, r, x);
	pushup(nowrt);
	return ;
}

inline void init() {
	for (int l = 1; l < 20; l++) {
		for (int i = 1; i <= n; i++) {
			fa[i][l] = fa[fa[i][l - 1]][l - 1];
		}
	}
	return ;
}

void dfs(int x) {
	int pos = id(v[x]);
	insert(root[x], root[fa[x][0]], 1, hn, pos);
	int v;
	for (int i = head[x]; ~i; i = nxt[i]) {
		v = to[i];
		if (v == fa[x][0]) continue;
		fa[v][0] = x;
		dep[v] = dep[x] + 1;
		dfs(v);
	}
	return ;
}

inline int LCA(int u, int v) {
	if (dep[u] < dep[v]) {
		u ^= v ^= u ^= v;
	}
	int l = 19;
	while (l--) {
		if (dep[fa[u][l]] >= dep[v]) u = fa[u][l];
	}
	if (u == v) return u;
	l = 19;
	while (l--) {
		if (fa[u][l] != fa[v][l]) {
			u = fa[u][l];
			v = fa[v][l];
		}
	}
	return fa[u][0];
}

int query(int rt1, int rt2, int rt3, int rt4, int l, int r, int k) {
	if (l == r) {
		return h[l];
	}
	int mid = (l + r) >> 1;
	int l1 = tre[rt1].l, l2 = tre[rt2].l;
	int l3 = tre[rt3].l, l4 = tre[rt4].l;
	int r1 = tre[rt1].r, r2 = tre[rt2].r;
	int r3 = tre[rt3].r, r4 = tre[rt4].r;
	int lsum = tre[l1].sum + tre[l2].sum - tre[l3].sum - tre[l4].sum;
	if (k <= lsum) {
		return query(l1, l2, l3, l4, l, mid, k);
	} else {
		return query(r1, r2, r3, r4, mid + 1, r, k - lsum);
	}
}

signed main() {
	memset(head, -1, sizeof head);
	read(n), read(m);
	for (int i = 1; i <= n; i++) {
		read(v[i]);
		h[i] = v[i];
	}
	sort(h + 1, h + 1 + n);
	hn = unique(h + 1, h + 1 + n) - h - 1;
	int u, v, k, lca, lstans = 0;
	for (int i = 1; i < n; i++) {
		read(u), read(v);
		add(u, v), add(v, u);
	}
	dfs(1);
	init();
	for (int i = 1; i <= m; i++) {
		read(u), read(v), read(k);
		u ^= lstans;
		lca = LCA(u, v);
		lstans = query(root[u], root[v], root[lca], root[fa[lca][0]], 1, hn, k);
		print(lstans);
	}
	return 0;
}