#include <bits/stdc++.h>

using namespace std;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef vector<vector<int> > vvi;

void DFS_finishing_time(vvi &G, vi &visited, vi &finishing_time, int u)
{
    visited[u] = 1;
    for(auto v : G[u])
    {
        if(!visited[v])
            DFS_finishing_time(G,visited,finishing_time,v);
    }
    finishing_time.push_back(u);
}
void DFS_compute_components(vvi &G, vi &visited, vi &component, int u)
{
    visited[u] = 1;
    component.push_back(u);
    for(auto v : G[u])
    {
        if(!visited[v])
            DFS_finishing_time(G,visited,component,v);
    }
}
vvi strongly_connected_components(vvi &G)
{
    //First DFS
    vi finishing_time;
    vi visited(G.size());
    for(int i = 0;i<visited.size();i++)
        if(!visited[i])
            DFS_finishing_time(G,visited,finishing_time,i);
    //compute GT
    vvi G2(G.size());
    for(int a = 0;a<G.size();a++)
        for(auto b : G[a])
            G2[b].push_back(a);

    //second DFS
    vvi ans;
    visited.assign(G.size(),0);
    for(int a = finishing_time.size()-1;a>=0;a--)
    {
        int i = finishing_time[a];
        if(!visited[i])
        {
            vi component;
            DFS_compute_components(G2,visited,component,i);
            ans.push_back(component);
        }
    }
    return ans;
}

void solve(){
    int n,m,k; cin >> n >> m >> k;
    vector<int> relevant(n);
    for(int i = 0;i<k;i++){
        int a; cin >> a;
        relevant[--a] = 1;
    }
    vector<vector<int> > G(n);
    for(int i = 0;i<m;i++){
        int a,b; cin >> a >> b;
        G[--a].push_back(--b);
    }
    vector<vector<int> > SCC = strongly_connected_components(G);
    vector<bool> containsK(SCC.size());
    vector<bool> inserted(SCC.size());
    vector<int> findSCC(n);
    for(int i = 0;i<SCC.size();i++){
        for(int a : SCC[i]){
            findSCC[a] = i;
            if(relevant[a])
                containsK[i] = true;
        }
    }
    vector<set<int> > G2(SCC.size());
    for(int u = 0;u<n;u++){
        for(int v : G[u]){
            if(findSCC[u] != findSCC[v])
                G2[findSCC[u]].insert(findSCC[v]);
        }
    }
    vector<int> getIn(SCC.size());
    for(int i = 0;i<SCC.size();i++){
        for(int v : G2[i]){
            getIn[v]++;
        }
    }
    vector<int> seq;
    int u = -1;
    for(int i = 0;i<G2.size();i++){
        if(getIn[i] == 0){
            if(!containsK[i]){
                for(int v : G2[i]){
                    getIn[v]--;
                }
                continue;
            }
            if(u != -1){
                cout << "-1" << endl;
                return;
            }
            u = i;
        }
    }
    while(u != -1){
        seq.push_back(u);
        inserted[u] = true;
        int newu = -1;
        queue<int> Q;
        for(int u2 : G2[u])
            Q.push(u2);
        while(!Q.empty()){
            int u2 = Q.front();
            Q.pop();
            if(--getIn[u2] <= 0){
                if(!containsK[u2]){
                    for(int v : G2[u2]){
                        if(--getIn[v] == 0)
                            Q.push(v);
                    }
                    continue;
                }
                if(newu != -1){
                    cout << "-1" << endl;
                    return;
                }
                newu = u2;
            }
        }
        u = newu;
    }
    for(int i = 0;i<SCC.size();i++){
        if(containsK[i] && !inserted[i]){
            cout << "-1" << endl;
            return;
        }
        sort(SCC[i].begin(),SCC[i].end());
    }
    for(int i : seq){
        for(int j : SCC[i]){
            if(relevant[j])
                cout << j+1 << " ";
        }
    }
    cout << endl;
}

int main()
{
    cin.sync_with_stdio(0);
    int t; cin >> t;
    for(int t1 = 0;t1<t;t1++){
        solve();
    }
    return 0;
}