#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

#define inp_s     ios_base::sync_with_stdio(false)
#define DRT()     int test_case;cin>>test_case;while(test_case--)

#define VI        vector<int>
#define VS        vector<string>
#define VLL       vector<LL>
#define PII       pair<int,LL>
#define all(c)    c.begin(),c.end()
#define sz(c)     (int)c.size()
#define clr(c)    c.clear()
#define pb        push_back
#define mp        make_pair

#define GI(x)     scanf("%d",&x)

#define FOR(i,a,b)      for(int i=(int)(a);i<(int)(b);i++)
#define RFOR(i,a,b)     for(int i=(int)(b)-1;i>=(int)(a);i--)

#define MOD       1000000007
#define EPS       1E-10

#define PI  acos(-1)

#define CASE(x)   cout << "Case #" << x << ": ";

vector<VI> graph , transpose;
vector<int> reqd;

vector<VI> cycles;
stack<int> vertices;

vector<int> visited;

void dfs1(int u)
{
	if(visited[u]) return ;
	visited[u] = 1;
	FOR(i,0,sz(graph[u]))
	{
		int v = graph[u][i];
		if(!visited[v])
			dfs1(v);
	}
	vertices.push(u);
}

void scc()
{
	int n = sz(graph);
	clr(visited);
	visited.resize(n);
	FOR(i,0,n) dfs1(i);
	clr(visited);
	visited.resize(n);
	while(!vertices.empty())
	{
		int ele = vertices.top();
		vertices.pop();
		if(visited[ele]) continue;
		
		queue<int> bfs;
		bfs.push(ele);
		visited[ele] = 1;
		VI xyz;

		while(!bfs.empty())
		{
			int ele = bfs.front();
			bfs.pop();
			xyz.pb(ele);

			FOR(i,0,sz(transpose[ele]))
			{
				int v = transpose[ele][i];
				if(visited[v]) continue;
				bfs.push(v);
				visited[v] = 1;
			}
		}
		sort(all(xyz));
		cycles.pb(xyz);
	}
}

vector<VI> treeGraph;
vector<int> newNodeId;

vector<int> in_degree;
vector<int> usedVertex;

vector<VI> KaunKaunHai;

void solve()
{
	int n , m , k;
	cin >> n >> m >> k;
	
	clr(graph);
	clr(KaunKaunHai);
	clr(treeGraph);
	clr(newNodeId);
	clr(cycles);
	clr(reqd);
	clr(transpose);
	clr(in_degree);
	clr(usedVertex);

	transpose.resize(n);
	graph.resize(n);
	KaunKaunHai.resize(n);
	usedVertex.resize(n);
	treeGraph.resize(n);
	newNodeId.resize(n);
	reqd.resize(k);
	in_degree.resize(n);
	
	FOR(i,0,k) cin >> reqd[i];
	FOR(i,0,k) reqd[i] -= 1;
	sort(all(reqd));
	
	while(m--)
	{
		int a , b;
		cin >> a >> b;
		a -= 1;
		b -= 1;
		graph[a].pb(b);
		transpose[b].pb(a);
	}
	scc();
	for(int i = 0; i < sz(cycles); i++)
	{
		int id = cycles[i][0];
		for(int j = 0; j < sz(cycles[i]); j++)
		{
			newNodeId[cycles[i][j]] = id;
		}
	}

	for(int i = 0; i < n; i++)
	{
		// ith vertex.
		int u = newNodeId[i];
		for(int j = 0; j < sz(graph[i]); j++)
		{
			int v = newNodeId[graph[i][j]];
			if(u == v) continue;
			treeGraph[u].pb(v);
		}
	}
	for(int i = 0; i < n; i++)
	{
		sort(all(treeGraph[i]));
		treeGraph[i].erase( unique( all(treeGraph[i]) ), treeGraph[i].end() );
		int x = sz(treeGraph[i]);
		for(int j = 0; j < sz(treeGraph[i]); j++)
		{
			int v = treeGraph[i][j];
			int u = i;
			in_degree[v] += 1;
			usedVertex[v] = 1;
		}
		if(x) usedVertex[i] = 1;
	}
	for(int i = 0; i < n; i++)
	{
		int id = newNodeId[i];
		KaunKaunHai[id].pb(i);
	}
	vector<int> ans(k);
	priority_queue< int , vector<int> , greater<int> > topoSort;
	for(int i = 0; i < n; i++)
	{
		if(usedVertex[i] == 0) continue;
		if(in_degree[i]) continue;
		for(int j = 0; j < sz(KaunKaunHai[i]); j++)
			topoSort.push(KaunKaunHai[i][j]);
	}

	// print SCC and debug

	int lala = 0;
	while(!topoSort.empty())
	{
		int ele = topoSort.top();
		topoSort.pop();

		if(binary_search(all(reqd) , ele))
			ans[lala++] = ele;
		for(int j = 0; j < sz(treeGraph[ele]); j++)
		{
			int v = treeGraph[ele][j];
			in_degree[v] -= 1;
			if(in_degree[v] == 0)
			{
				for(int j = 0; j < sz(KaunKaunHai[v]); j++)
				{
					topoSort.push(KaunKaunHai[v][j]);
				}
			}
		}
	}
	FOR(i,0,k)
		cout << ans[i] + 1 << " ";
	cout << endl;
}

int main()
{
	inp_s;
	DRT()
	{
		solve();
	}
    	return 0;
}