#include <iostream>
#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
using namespace std;

vector<int> Graph[100111];
vector<int> RevGraph[100111];
bool TFO[100111];
int t;
int n,m,k;
int C[100111];
int outvals[100111];
int valctr=0;
int hasval[100111];
bool special[100111];
bool specialcomp[100111];

void DFS1(int ver)
{
    if (TFO[ver])
    return;

    TFO[ver]=true;

    int i;

    for (i=0;i<Graph[ver].size();i++)
    {
        DFS1(Graph[ver][i]);
    }

    valctr++;
    outvals[ver]=valctr;
    hasval[valctr]=ver;

    return;
}

int components=0;
int whatcomp[100111];
vector<int> compspecials[100111];

void DFS2(int ver)
{
    if (TFO[ver])
    return;

    TFO[ver]=true;
    whatcomp[ver]=components;
    //cout<<ver<<" is in "<<components<<endl;

    if (special[ver])
    {
        compspecials[components].push_back(ver);
        specialcomp[components]=true;
    }

    int i;

    for (i=0;i<RevGraph[ver].size();i++)
    {
        DFS2(RevGraph[ver][i]);
    }

    return;
}

vector<int> DAG[100111];
int ingoing[100111];
vector<int> TOPS;
vector<int> order;
vector<int> ans;

bool LookFor(int ver,int goal)
{
    if (ver==goal)
    return true;
    if (TFO[ver])
    return false;

    TFO[ver]=true;

    int i;

    for (i=0;i<DAG[ver].size();i++)
    {
        if (LookFor(DAG[ver][i],goal))
        return true;
    }

    return false;
}

bool GoodOrder()
{
    int i;

    memset(TFO,false,sizeof(TFO));
    for (i=(int)order.size()-2;i>=0;i--)
    {
        if (!LookFor(order[i],order[i+1]))
        return false;
    }

    return true;
}

int main()
{
    int i,j;
    int test;
    int a,b;
    int v;
    int uk;

    scanf("%d",&t);

    for (test=1;test<=t;test++)
    {
        scanf("%d %d %d",&n,&m,&k);

        memset(special,false,sizeof(special));
        memset(specialcomp,false,sizeof(specialcomp));
        memset(ingoing,0,sizeof(ingoing));

        for (i=1;i<=n;i++)
        {
            Graph[i].clear();
            RevGraph[i].clear();
            DAG[i].clear();
        }
        valctr=0;

        for (i=1;i<=k;i++)
        {
            scanf("%d",&C[i]);

            special[ C[i] ]=true;
        }

        for (i=1;i<=m;i++)
        {
            scanf("%d %d",&a,&b);

            Graph[a].push_back(b);
            RevGraph[b].push_back(a);
        }

        memset(TFO,false,sizeof(TFO));
        for (i=1;i<=n;i++)
        {
            if (!TFO[i])
            {
                DFS1(i);
            }
        }

        memset(TFO,false,sizeof(TFO));
        components=0;
        for (i=n;i>=1;i--)
        {
            v=hasval[i];
            if (!TFO[v])
            {
                components++;
                compspecials[components].clear();
                DFS2(v);

                sort(compspecials[components].begin(),compspecials[components].end());
            }
        }

        for (i=1;i<=n;i++)
        {
            for (j=0;j<Graph[i].size();j++)
            {
                if (whatcomp[i]==whatcomp[ Graph[i][j] ])
                continue;

                DAG[ whatcomp[i] ].push_back(whatcomp[ Graph[i][j] ]);
                ingoing[ whatcomp[ Graph[i][j] ] ]++;
            }
        }

        TOPS.clear();
        for (i=1;i<=components;i++)
        {
            if (ingoing[i]==0)
            {
                TOPS.push_back(i);
            }
        }

        uk=0;
        order.clear();
        while(uk<TOPS.size())
        {
            v=TOPS[uk];

            //cout<<"Getting "<<v<<endl;

            if (specialcomp[v])
            order.push_back(v);

            for (i=0;i<DAG[v].size();i++)
            {
                ingoing[ DAG[v][i] ]--;

                if (ingoing[ DAG[v][i] ]==0)
                {
                    TOPS.push_back(DAG[v][i]);
                }
            }

            uk++;
        }

        if (!GoodOrder())
        {
            printf("-1\n");
        }
        else
        {
            //cout<<"here though"<<endl;
            //for (i=0;i<order.size();i++)
            //{
            //    cout<<"order "<<order[i]<<endl;
            //}

            ans.clear();
            for (i=0;i<order.size();i++)
            {
                for (j=0;j<compspecials[ order[i] ].size();j++)
                {
                    ans.push_back( compspecials[ order[i] ][j] );
                }
            }

            for (i=0;i<ans.size();i++)
            {
                if (i!=0)
                printf(" ");
                printf("%d",ans[i]);
            }
            printf("\n");
        }
    }

    return 0;
}