#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MOD = 1e9 + 447;
const int BASE = 547;

int add(int a, int b) {
	if (a + b < MOD)
		return a + b;
	return a + b - MOD;
}

int sub(int a, int b) {
	if (a >= b)
		return a - b;
	return a + MOD - b;
}

int mul(int a, int b) {
	return a * 1ll * b % MOD;
}

int pw(int a, int n) {
	int ans = 1;
	while (n) {
		if (n & 1)
			ans = mul(ans, a);
		n >>= 1;
		a = mul(a, a);
	}
	return ans;
}

const int MAXN = 3 * 200200;
int BASEPOW[MAXN];
int ANTIBASEPOW[MAXN];

struct HashDeque {
	deque<int> vals;
	deque<int> letters;
	int power;
	int delta;
	HashDeque(): power(0), delta(0) {}
	void clear() {
		power = 0;
		delta = 0;
		vals.clear();
		letters.clear();
	}
	void push_back(int x) { // letter x
		letters.emplace_back(x);
		int real_hash = get_real(vals.size());
		real_hash = add(real_hash, mul(x, BASEPOW[vals.size()]));
		int new_val = mul(sub(real_hash, delta), ANTIBASEPOW[power]);
		vals.emplace_back(new_val);
	}
	void push_front(int x) { // letter x
		letters.emplace_front(x);
		int real_hash = x;
		++power;
		delta = add(mul(delta, BASE), x);
		int new_val = mul(sub(real_hash, delta), ANTIBASEPOW[power]);
		vals.push_front(new_val);
	}
	int get_real(int len) const {
		if (len == 0)
			return 0;
		//cout << ' ' << len << ' ' << vals[len - 1] << ' ' << power << ' ' << BASEPOW[power] << ' ' << delta << '\n';
		return add(mul(vals[len - 1], BASEPOW[power]), delta);
	}
	int size() const {
		return letters.size();
	}
};

bool operator <(const HashDeque& A, const HashDeque& B) {
	int left = 0, right = min(A.size(), B.size()) + 1;
	while (right - left > 1) {
		int mid = (left + right) / 2;
		int kek1 = A.get_real(mid);
		int kek2 = B.get_real(mid);
		if (kek1 == kek2)
			left = mid;
		else
			right = mid;
	}
	if (left == A.size() && left == B.size())
		return false;
	if (left == A.size())
		return true;
	if (left == B.size())
		return false;
	return A.letters[left] < B.letters[left];
}

vector<int> G[MAXN];
char ans[MAXN];
bool marked[MAXN];
int id[MAXN];
HashDeque deques[MAXN];

void dfs(int v) {
	id[v] = v;
	for (int u : G[v])
		dfs(u);
	stable_sort(G[v].begin(), G[v].end(), [](int a, int b) {
		return deques[id[a]] < deques[id[b]];
	});
	if (marked[v])
		deques[id[v]].push_back('a' - 1);
	for (int i = 0; i < G[v].size(); ++i) {
		int u = G[v][i];
		ans[u] = char('a' + i);
		deques[id[v]].push_back('a' + i);
		if (deques[id[v]].size() < deques[id[u]].size()) {
			for (int i = int(deques[id[v]].size()) - 1; i >= 0; --i)
				deques[id[u]].push_front(deques[id[v]].letters[i]);
			swap(id[v], id[u]);
		} else {
			for (int x : deques[id[u]].letters)
				deques[id[v]].push_back(x);
		}
	}
	deques[id[v]].push_back('z' + 1);
}


void solve() {
	int n, m;
	cin >> n >> m;
	fill(marked, marked + n + 1, false);
	for (int i = 1; i <= n; ++i) {
		int p;
		cin >> p;
		G[p].emplace_back(i);
	}
	for (int i = 0; i < m; ++i) {
		int x;
		cin >> x;
		marked[x] = true;
	}
	for (int i = 0; i <= n; ++i)
		deques[i].clear();
	dfs(0);
	for (int i = 1; i <= n; ++i)
		cout << ans[i];
	cout << '\n';
	for (int i = 0; i <= n; ++i)
		G[i].clear();
}


int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	
	BASEPOW[0] = 1;
	for (int i = 1; i < MAXN; ++i)
		BASEPOW[i] = mul(BASEPOW[i - 1], BASE);
	int ANTIBASE = pw(BASE, MOD - 2);
	ANTIBASEPOW[0] = 1;
	for (int i = 1; i < MAXN; ++i) {
		ANTIBASEPOW[i] = mul(ANTIBASEPOW[i - 1], ANTIBASE);
	}

	int t;
	cin >> t;
	while (t--) {
		solve();
	}
	return 0;
}