#include <iostream>
#include <vector>
#include <cassert>
using namespace std;

const int MAXN = 1 << 18;

vector<int> tree[MAXN];
uint64_t xor_depth[MAXN];
uint64_t value[MAXN];
uint64_t dp[MAXN]; // dp[x] = xor sum of value[node] | (depth[node] & x == 0)

void dfs(int node, int parent, int depth) {
	xor_depth[depth] ^= value[node];
	for (const int& son: tree[node]) {
		if (son == parent) {
			continue;
		}
		
		dfs(son, node, depth + 1);
	}
}

int main() {
	cin.tie(0);
	ios_base::sync_with_stdio(false);
	int n, q; cin >> n >> q;
	assert(1 <= n && n <= 200000);
	assert(1 <= q && q <= 200000);
	for (int i = 1; i < n; ++i) {
		int x, y; cin >> x >> y;
		assert(0 <= x && x < n);
		assert(0 <= y && y < n);
		tree[x].push_back(y);
		tree[y].push_back(x);
	}
	for (int i = 0; i < n; ++i) {
		cin >> value[i];
		assert(0 <= value[i] && value[i] <= 1000000000000000000ULL);
	}
	
	dfs(0, -1, 0);
	
	int log_2 = 0, next_pow2 = 1;
	while (next_pow2 < n) {
		log_2++;
		next_pow2 *= 2;
	}

	for (int i = 0; i < next_pow2; ++i) {
		int reverse_mask = ~i & (next_pow2 - 1);
		dp[reverse_mask] = xor_depth[i];
	}

	for (int i = 0; i < log_2; ++i) {
		for (int j = next_pow2 - 1; j >= 0; --j) {
			if ((j & (1 << i)) == 0) {
				dp[j] ^= dp[j ^ (1 << i)];
			}
		}
	}

	while (q--> 0) {
		int64_t delta; cin >> delta; 
		assert(0 <= delta && delta <= 1000000000000000000LL);
		delta--;
		if (delta == -1) {
			cout << value[0] << '\n';
		} else {
			cout << dp[delta & (next_pow2 - 1)] << '\n';		
		}
	}
}