#pragma comment (linker, "/STACK:128000000")
#include <iostream> 
#include <cstdio> 
#include <fstream>
#include <functional>
#include <set> 
#include <map> 
#include <vector> 
#include <queue> 
#include <stack> 
#include <cmath> 
#include <algorithm> 
#include <cstring> 
#include <bitset> 
#include <ctime> 
#include <sstream>
#include <stack> 
#include <cassert> 
#include <list> 
#include <deque>

using namespace std;

#define mp make_pair
#define pb push_back

typedef long long li;
typedef long long i64;
typedef pair <int, int> pi;
typedef vector <int> vi;
typedef double ld;
typedef vector<int> vi;
typedef pair <int, int> pi;

void solve();

//int timer = 0;
#define FILENAME ""

int main() {
	string s = FILENAME;
#ifdef YA
	//assert(!s.empty());
	freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	//cerr<<FILENAME<<endl;
	//assert (s != "change me please");
	clock_t start = clock();
#else
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	//freopen(FILENAME ".in", "r", stdin);
	//freopen(FILENAME ".out", "w", stdout); 
	cin.tie(0);
#endif
	cout.sync_with_stdio(0);
	cout.precision(10);
	cout << fixed;
	int t = 1;

	cin >> t;
	for (int i = 1; i <= t; ++i) {
		//++timer;
		//cout << "Case #" << i << ": ";
		solve();
	}
#ifdef YA
	cerr << "\n\n\n" << (clock() - start) / 1.0 / CLOCKS_PER_SEC << "\n\n\n";
#endif
	return 0;
}

int n, m, k;
vector <vector <int> > g, revg;

vector <int> used;
vector <int> order;

void dfs(int v) {
	used[v] = 1;
	for (int to : g[v]) {
		if (!used[to]) {
			dfs(to);
		}
	}

	order.push_back(v);
}

vector <int> color;
vector < vector <int> > comps;
vector <int> to_visit;

void dfs_rev(int v) {
	comps[color[v]].push_back(v);

	for (int to : revg[v]) {
		if (color[to] == -1) {
			color[to] = color[v];
			dfs_rev(to);
		}
	}
}

bool v_cmp(int x, int y) {
	if (color[x] != color[y]) {
		return color[x] < color[y];
	}
	return x < y;
}

vector <vector <int>> small_g;

void solve() {
	cin >> n >> m >> k;

	g.clear();
	revg.clear();
	to_visit.clear();
	small_g.clear();
	comps.clear();
	color.clear();
	used.clear();
	order.clear();

	to_visit.resize(k);
	for (int i = 0; i < k; ++i) {
		cin >> to_visit[i];
		--to_visit[i];
	}
	g.resize(n);
	revg.resize(n);
	used.resize(n);
	color.resize(n, -1);

	for (int i = 0; i < m; ++i) {
		int x, y;
		cin >> x >> y;
		--x;
		--y;
		g[x].push_back(y);
		revg[y].push_back(x);
	}

	for (int i = 0; i < n; ++i) {
		if (!used[i]) {
			dfs(i);
		}
	}

	for (int i = order.size() - 1; i >= 0; --i) {
		int v = order[i];
		if (color[v] == -1) {
			color[v] = comps.size();
			comps.push_back(vector <int>());
			dfs_rev(v);
		}
	}

	sort(to_visit.begin(), to_visit.end(), v_cmp);

	vector <int> comp_ord;
	for (int i = 0; i < to_visit.size(); ++i) {
		if (comp_ord.empty() || comp_ord.back() != color[to_visit[i]]) {
			comp_ord.push_back(color[to_visit[i]]);
		}
	}


	small_g.resize(comps.size());
	for (int i = 0; i < comps.size(); ++i) {
		for (int v : comps[i]) {
			for (int to : g[v]) {
				small_g[i].push_back(color[to]);
			}
		}
		sort(small_g[i].begin(), small_g[i].end());
		small_g[i].erase(unique(small_g[i].begin(), small_g[i].end()), small_g[i].end());


	}
	
	vector <int> dp(comps.size(), 0);
	dp[comp_ord[0]] = 1;

	bool f = false;
	for (int i = 0; i < comps.size(); ++i) {
		for (int to : small_g[i]) {
			dp[to] = max(dp[to], dp[i]);
			if (dp[i] < comp_ord.size() && to == comp_ord[dp[i]]) {
				dp[to] = max(dp[to], dp[i] + 1);
			}
		}
		if (dp[i] == comp_ord.size()) {
			f = true;
		}
	}

	if (!f) {
		cout << -1 << endl;
	}
	else {
		for (int i = 0; i < to_visit.size(); ++i) {
			cout << to_visit[i] + 1 << " ";
		}
		cout << endl;
	}
}