#include <bits/stdc++.h>
#define MAXN 200005
using namespace std;
int n, m, k;
int city[MAXN], componentNumber[MAXN], reachable[MAXN];

vector<int> g[MAXN], gr[MAXN], gg[MAXN];
bool used[MAXN];
vector<int> order, component, importantComponent;
vector<vector<int> > components, importantComponents;
void init() {
	for (int i = 0; i < n; i++)
		g[i].clear(), gr[i].clear(), city[i] = 0, reachable[i] = 0;
	order.clear();
	components.clear();
	importantComponents.clear();
}

void dfs1(int v) {
	used[v] = true;
	for (int i = 0; i < int(g[v].size()); ++i)
		if (!used[g[v][i]])
			dfs1(g[v][i]);
	order.push_back(v);
}

void dfs2(int v) {
	used[v] = true;
	component.push_back(v);
	if (city[v])
		importantComponent.push_back(v);
	componentNumber[v] = components.size();
	for (int i = 0; i < int(gr[v].size()); ++i)
		if (!used[gr[v][i]])
			dfs2(gr[v][i]);
}
void scc() {
	for (int i = 0; i < n; i++)
		used[i] = 0;
	for (int i = 0; i < n; i++)
		if (!used[i])
			dfs1(i);
	for (int i = 0; i < n; i++)
		used[i] = 0;
	for (int i = 0; i < n; ++i) {
		int v = order[n - 1 - i];
		if (!used[v]) {
			component.clear();
			importantComponent.clear();
			dfs2(v);
			components.push_back(component);
			sort(importantComponent.begin(), importantComponent.end());
			importantComponents.push_back(importantComponent);
		}
	}
}
void compress() {
	for (int i = 0; i < int(components.size()); i++)
		gg[i].clear();
	for (int i = 0; i < n; i++)
		for (int j = 0; j < int(g[i].size()); j++)
			if (componentNumber[i] != componentNumber[g[i][j]])
				gg[componentNumber[i]].push_back(componentNumber[g[i][j]]);
}

void dfss(int v) {
	used[v] = true;
	for (int i = 0; i < int(gg[v].size()); ++i) {
		int to = gg[v][i];
		if (!used[to])
			dfss(to);
	}
	order.push_back(v);
}

void topologicalSort() {
	int n = components.size();
	for (int i = 0; i < n; ++i)
		used[i] = false;
	order.clear();
	for (int i = 0; i < n; ++i)
		if (!used[i])
			dfss(i);
	reverse(order.begin(), order.end());
}

int dfs(int node) {
	if (used[node])
		return reachable[node];
	int ret = 0;
	used[node] = true;
	for (int i = 0; i < int(gg[node].size()); i++)
		ret = max(ret, dfs(gg[node][i]));
	if (importantComponents[node].size())
		ret++;
	return reachable[node] = ret;
}

int main() {
	ios::sync_with_stdio(0);

	int t;
	scanf("%d", &t);
	while (t--) {
		scanf("%d%d%d", &n, &m, &k);
		init();
		for (int i = 0; i < k; i++) {
			int u; scanf("%d", &u); --u;
			city[u] = 1;
		}
		for (int i = 0; i < m; i++) {
			int u, v;
			scanf("%d%d", &u, &v);
			--u;
			--v;
			g[u].push_back(v);
			gr[v].push_back(u);
		}
		scc();
		compress();
		topologicalSort();
		bool valid = true;
		int cnt = 0;
		for (int i = 0; i < int(order.size()); i++)
			if (importantComponents[i].size())
				cnt++;

		for (int i = 0; i < int(order.size()); i++)
			used[i] = false;
		for (int i = 0; i < int(order.size()); i++)
			if (importantComponents[order[i]].size()) {
				valid = dfs(order[i]) == cnt;
				break;
			}

		if (!valid) {
			printf("-1\n");
			continue;
		}
		for (int i = 0; i < int(order.size()); i++)
			for (int j = 0; j < int(importantComponents[order[i]].size()); j++)
				printf("%d ", importantComponents[order[i]][j] + 1);
		printf("\n");
	}

	return 0;
}