#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <string>
#include <cmath>
#include <memory.h>
#include <sstream>
#include <stack>
#include <fstream>
#include <cstdio>
#include <unordered_map>
#include <map>
#include <list>
#include <stdlib.h>
#include <queue>
#include <set>
using namespace std;

/*
*/

class SCC
{
private:
	vector<vector<int> > gt;
	vector<int> f;
	vector<bool> tk;
public:
	vector<int> SCCG;
	vector<vector<int> > g;
	vector<vector<int> > dag;
	vector<vector<int> > comp;
	void dfs1(int i)
	{
		tk[i] = true;
		for (int j = 0; j < g[i].size(); j++)
		{
			if (!tk[g[i][j]]) dfs1(g[i][j]);
		}
		f.push_back(i);
	}
	void dfs2(int i, int group)
	{
		tk[i] = true;
		SCCG[i] = group;
		for (int j =0; j < gt[i].size(); j++)
		{
			if (!tk[gt[i][j]]) dfs2(gt[i][j], group);
		}
	}

	void computeSCC()
	{
		SCCG = vector<int> (g.size(), -1);
		tk = vector<bool> (g.size(), false);
		f.clear();
		for (int i = 0; i < g.size(); i++)
		{
			if (!tk[i]) dfs1(i);
		}
		gt = vector<vector<int> >(g.size());
		for (int i = 0; i < g.size(); i++)
		{
			for (int j = 0; j < g[i].size(); j++)
			{
				gt[g[i][j]].push_back(i);
			}
		}
		int gr = 0;
		tk = vector<bool>(g.size(), false);
		for (int i = f.size()-1; i >= 0; i--)
		{
			if (!tk[f[i]])
			{
				dfs2(f[i], gr);
				gr++;
			}
		}
		dag = vector<vector<int> > (gr);
		comp = vector<vector<int> > (gr);
		set<pair<int, int> > edges;
		
		for (int i = 0; i < g.size(); i++)
		{
			comp[SCCG[i]].push_back(i);
			for (int j = 0; j < g[i].size(); j++)
			{
				int u, v;
				u = i;
				v = g[i][j];
				if (SCCG[u] != SCCG[v])
				{
					if (edges.count(make_pair(SCCG[u], SCCG[v])) == 0)
					{
						dag[SCCG[u]].push_back(SCCG[v]);
						edges.insert(make_pair(SCCG[u], SCCG[v]));
					}

				}
			}
		}
	}	
};

int K;
bool want[100001];
int dp[100001];
int p[100001];
vector<vector<int> > dag, comp;
int sol(int i)
{
	if (dp[i] != -1) return dp[i];
	int cnt = 0;
	for (int j = 0; j < comp[i].size(); j++)
	{
		if (want[comp[i][j]])
		{
			cnt++;
		}
	}
	dp[i] = cnt;
	p[i] = -1;
	for(int j = 0; j < dag[i].size(); j++)
	{
		if (cnt+sol(dag[i][j]) >= dp[i])
		{
			p[i] = dag[i][j];
			dp[i] = cnt+sol(dag[i][j]);
		}
	}
	return dp[i];
}
int main()
{
	int T;
	cin>>T;
	SCC scc;
	while (T--)
	{
		int n, m, k;
		cin>>n>>m>>k;
		K = k;
		memset(dp, -1, sizeof(dp));
		memset(want, 0, sizeof(want));
		for (int i = 0; i < K; i++)
		{
			int x;
			cin>>x;
			x--;
			want[x] = true;
		}
		scc.g = vector<vector<int> > (n);
		for (int i = 0; i < m; i++)
		{
			int x, y;
			cin>>x>>y;
			x--;
			y--;
			scc.g[x].push_back(y);
		}
		scc.computeSCC();
		comp = scc.comp;
		dag = scc.dag;
		int in = -1;
		int mx = 0;
		for (int i = 0; i < dag.size(); i++)
		{
			if (sol(i) >= mx)
			{
				mx = dp[i];
				in = i;
			}
		}
		if (mx != K)
		{
			cout<<-1<<endl;
		}
		else
		{
			vector<int> ord;
			while (in != -1 && ord.size() < K)
			{
				for (int i = 0; i < comp[in].size(); i++)
				{
					if (want[comp[in][i]]) ord.push_back(comp[in][i]);
				}
				in = p[in];
			}
			cout<<ord[0]+1;
			for (int i = 1; i < K; i++)
			{
				cout<<" "<<ord[i]+1;
			}
			cout<<endl;
		}
	}
}