#include <iostream>
#include <vector>
#include <set>
#include <stack>
#include <string.h>
#include <queue>
using namespace std;


int important[100005];
int scc[100005];
int visited[100005];
int incoming[100005];
int level[100005];

stack<int> stk;
vector< vector<int> > graph(100005);
vector< vector<int> > rgraph(100005);
vector<int> ans;

int num_scc;

struct Comp {
    vector<int> imps;
    set<int> next;
};

Comp comp[100005];

void dfs1(int u) {
    visited[u] = 1;
    for (int i=0; i<graph[u].size(); i++) {
        int v = graph[u][i];
        if (!visited[v]) {
            dfs1(v);
        }
    }
    stk.push(u);
}

void markSCC(int u, int c) {
    visited[u] = 1;
    scc[u] = c;
    //cout<<u<<" "<<c<<endl;
    for (int i=0; i<rgraph[u].size(); i++) {
        int v = rgraph[u][i];
        if (!visited[v]) {
            markSCC(v,c);
        }
    }
}


int main() {
    int t;
    cin>>t;
    while(t--) {
    int n,m,k;
    cin>>n>>m>>k;
    memset(incoming, 0, sizeof(incoming));
    memset(level, 0, sizeof(level));
    memset(visited, 0, sizeof(visited));
    memset(scc, 0, sizeof(scc));
    memset(important, 0, sizeof(important));
    num_scc = 0;
    for (int i=0; i<=n; i++) {
        graph[i].clear();
        rgraph[i].clear();
        comp[i].next.clear();
        comp[i].imps.clear();
    }
    ans.clear();
    for (int i=0; i<k; i++) {
        int x; cin>>x;
        important[x] = 1;
    }
    for (int i=0; i<m; i++) {
        int a,b;
        cin>>a>>b;
        graph[a].push_back(b);
        rgraph[b].push_back(a);
    }
    for (int i=1; i<=n; i++) {
        if (!visited[i]) {
            dfs1(i);
        }
    }
    memset(visited, 0, sizeof(visited));
    while (!stk.empty()) {
        int u = stk.top();
        stk.pop();
        if (!visited[u]) {
            num_scc++;
            markSCC(u, num_scc);
        }
    }
    for (int i=1; i<=n; i++) {
        int c = scc[i];
        if(important[i]) {
            comp[c].imps.push_back(i);
        }
        for (int j=0; j<graph[i].size(); j++) {
            int v = graph[i][j];
            if (scc[i]==scc[v])continue;
            if (comp[c].next.find(scc[v])==comp[c].next.end()) {
                comp[c].next.insert(scc[v]);
                incoming[scc[v]]++;
            }
        }
    }


    queue<int> q;
    for (int i=1; i<=num_scc; i++) {
        if (incoming[i]==0) {
            q.push(i);
        }
        //cout<<"incoming "<<i<<" "<<incoming[i]<<endl;
    }

    int last = -1;
    int flag = 0;
    while(!q.empty()) {
        int c = q.front();
     //   cout<<c<<endl;
        q.pop();
        if (comp[c].imps.size()!=0) {
            if (last == level[c]) {
                flag = 1;
                break;
            }
            last = level[c];
            int sz = comp[c].imps.size();
            for(int i=0; i<sz; i++) {
                ans.push_back(comp[c].imps[i]);
            }
        }
        set<int>::iterator it = comp[c].next.begin();
        while(it!=comp[c].next.end()) {
            int v = *it;
            incoming[v]--;
     //       cout<<c<<" "<<v<<endl;
            if (incoming[v]==0) {
                q.push(v);
                level[v] = level[c]+1;
            }
            it++;
        }
    }

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