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

#define endl "\n"
#define LL long long
#define deb(x) cerr<<#x<<" : "<<x<<" "
#define dnl    cerr<<endl
#define FOR(i,n) for(int i=0;i<n;i++)

#define cnd     tree[idx]
#define lnd     idx*2,b,(b+e)/2
#define rnd     idx*2+1,(b+e)/2 + 1,e

typedef pair<int,int> pii;

LL power(LL a,LL b,LL m){
    if(b==0)return 1;
    if(b==1)return a%m;
    LL x = power(a,b>>1,m);
    x = (x*x)%m;
    if(b%2){
        x = (x*a)%m;
    }
    return x;
}

const int mx = 1e5+5;
LL P[2][mx];
const int base[4]={23, 29,37,79};
const int mod[2]={(LL)1e9+7, (LL)1e9+9};

LL globalhash[2];
LL hashval[2][mx];
int cntofhash=2;

inline LL getcurrenthash(){
    LL x = globalhash[0], y = globalhash[1];
    return (x<<31)^y;
}

struct dsu_save {
    int v, rnkv, u, rnku;
    dsu_save() {}
    dsu_save(int _v, int _rnkv, int _u, int _rnku)
        : v(_v), rnkv(_rnkv), u(_u), rnku(_rnku) {}
};

struct dsu_with_rollbacks {
    vector<int> p, rnk, sz;
    int comps;
    stack<dsu_save> op;
    int N;
    dsu_with_rollbacks() {}
    void add(int u){
        FOR(i,2){
            globalhash[i] += power(base[i+2],hashval[i][u],mod[i]);
            globalhash[i] %= mod[i];
        }
    }
    void rem(int u){
        FOR(i,2){
            globalhash[i] -= power(base[i+2],hashval[i][u],mod[i]);
            globalhash[i] += mod[i];
            globalhash[i] %= mod[i];
        }
    }
    void init(int n) {
        p.resize(n+5);
        rnk.resize(n+5);
        N = n;
        while(!op.empty())op.pop();
        for (int i = 0; i <= n; i++) {
            p[i] = i;
            rnk[i] = 0;
            FOR(j,cntofhash){
                hashval[j][i] = P[j][i];
                globalhash[j] += power(base[j+2],P[j][i],mod[j]);
                globalhash[j] %= mod[j];
            }
        }
        comps = n;
    }
    int find_set(int v) {
        return (v == p[v]) ? v : find_set(p[v]);
    }
    bool unite(int v, int u) {
        v = find_set(v);
        u = find_set(u);
        if (v == u)
            return false;
        comps--;
        if (rnk[v] > rnk[u])
            swap(v, u);
        op.push(dsu_save(v, rnk[v], u, rnk[u]));
        p[v] = u;
        rem(u);
        rem(v);
        FOR(i,2){
            hashval[i][u] += hashval[i][v];
            hashval[i][u] %= mod[i];
        }
        add(u);
        if (rnk[u] == rnk[v])
            rnk[u]++;
        return true;
    }
    void rollback() {
        if (op.empty())
            return;
        dsu_save x = op.top();
        op.pop();
        comps++;
        rem(x.u);
        FOR(i,2){
            hashval[i][x.u] -= hashval[i][x.v];
            hashval[i][x.u] += mod[i];
            hashval[i][x.u] %= mod[i];
        }
        add(x.u);
        add(x.v);
        p[x.v] = x.v;
        rnk[x.v] = x.rnkv;
        p[x.u] = x.u;
        rnk[x.u] = x.rnku;
    }

    void show(){
        for(int i=1;i<=N;i++){
            deb(i);deb(p[i]);deb(hashval[1][i]);
            dnl;
        }
        FOR(i,cntofhash)deb(globalhash[i]);dnl;
    }
} dsu;


struct oper{
    int typ;
    int u,v;
    int dest;
    bool united;
    void reset(){
        typ=0,u=0,v=0,dest=0,united=0;
    }
};
int posinq[4*mx];
oper oplist[4*mx];
LL finalhash[mx];
LL hashoftim[4*mx];
vector<oper> g[mx];
int curtime;
int kartime[4*mx];



void buildtimeline(int u,oper x){
    curtime++;
    oplist[curtime]=x;
    posinq[u]=curtime;
    kartime[curtime] = u;
    for(oper op:g[u]){
        buildtimeline(op.dest,op);
    }
    curtime++;
    x.typ *= -1;
    oplist[curtime] = x;
}



struct QueryTree {
    vector<oper> tree[10*mx];
    int T;
    QueryTree() {}
    inline void init(int _T){
        T = _T;
        FOR(i,4*_T+400)tree[i].clear();
//        tree.resize(4 * T + 400);

    }
    inline void add_query_to_tree(int idx,int b,int e,int l,int r,oper q){
        if(l>e or r<b)return;
        if(l<=b and r>=e){
            q.united=0;
            cnd.push_back(q);
            return;
        }
        add_query_to_tree(lnd,l,r,q);
        add_query_to_tree(rnd,l,r,q);
    }
    inline void add_query(oper q, int l, int r) {
        add_query_to_tree(1, 1, T, l, r, q);
    }

    void offline_dcp(int idx,int b,int e){
        for(oper &q:cnd){
            q.united = dsu.unite(q.u,q.v);
        }
        hashoftim[b] = getcurrenthash();
        if(b==e){

        }
        else{
            offline_dcp(lnd);
            offline_dcp(rnd);
        }
        for(oper q:cnd){
            if(q.united){
                dsu.rollback();
            }
        }
    }
    void solve(){
        offline_dcp(1,1,T);
    }
} DCP;

vector<int> groups[mx];

void tcreset(int n,int k){
    FOR(i,k+2){
        finalhash[i] = 0;
        groups[i].clear();
        g[i].clear();
    }
    FOR(i,curtime+2){
        hashoftim[i]=0;
        oplist[i].reset();
    }
    FOR(i,2){
        globalhash[i]=0;
        FOR(j,n)hashval[i][j] = 0;
    }
    curtime = 0;
    FOR(i,n+2)posinq[i] = 0;
}





/*
3
8 5 2
1 5
1 4
1 add 2 4
1 add 3 4
1 add 2 4
4 add 3 4
4 add 1 3
5 add 1 3
2 add 2 3


*/



void solve(int cs){
    int n,m,k;
    vector<vector<int>> timeline;
    cin>>k>>n>>m;
    dsu.init(n);
//    dsu.show();
    curtime = 1;
    vector<vector<int>> edges;
    FOR(ii,m){
        int u,v;
        cin>>u>>v;
//        dsu.unite(u,v);
        oper cop;
        cop.dest=0,cop.typ=1;
        cop.u=u,cop.v=v;
        oplist[curtime++] = cop;
        edges.push_back({u,v});
    }
    FOR(i,k-1){
        int par;string s;int u,v;
        int typ;
        cin>>par>>s>>u>>v;
        if(s=="add")typ=1;
        else typ=-1;
        g[par].push_back({typ,u,v,i+2});
    }

    buildtimeline(1,{0,0,0,0});
    for(auto e:edges){
        oplist[curtime++] = {-1,e[0],e[1],0};
    }
    map<pii,int> mp;
    DCP.init(curtime);
    vector<int> used(curtime+2,0);
    for(int i=1;i<=curtime;i++){
        int u = oplist[i].u, v = oplist[i].v;
        int t = oplist[i].typ;
        if(u > v)swap(u,v);
        pii x(u,v);
        if(t==0)continue;
        if( t==-1 ){
            if(mp.find(x)==mp.end() or mp[x]==0){
            }
            else{
                int l = mp[x];
//                timeline.push_back({l,i-1,u,v});
                DCP.add_query({1,u,v,0,0},l,i-1);
                mp[x] = 0;
                used[l]=1;
            }
        }
        else if(t==1){
            mp[x] = i;
        }
    }



//
//    for(auto xx:timeline){
//        oper cur;cur.typ=1,cur.u=xx[2],cur.v=xx[3],cur.dest=0;
//        DCP.add_query(cur,xx[0],xx[1]);
//    }
    for(int i=1;i<=curtime;i++){
        if(oplist[i].typ==1 and !used[i]){
            int u = oplist[i].u, v = oplist[i].v;
//            deb(u);deb(v);deb(i);dnl;
            DCP.add_query(oplist[i],i,curtime);
        }
    }
    DCP.solve();

    unordered_map<LL,int> gmap;
    int groupcount = 0;
//    gmap[finalhash[1]] = 1;
    for(int i=1;i<=k;i++){
        int t = posinq[i];
        LL cx = hashoftim[t];
        if(gmap.find(cx)==gmap.end()){
            gmap[cx]= i;
            groups[i].push_back(i);
            groupcount++;
        }
        else{
            int px = gmap[cx];
            groups[px].push_back(i);
        }
    }

//
    cout<<groupcount<<endl;
    for(int i=1;i<=k;i++){
        if((int)groups[i].size() > 0){
            cout<<(int)groups[i].size();
            for(int g:groups[i])cout<<" "<<g;
            cout<<endl;
        }
    }
    tcreset(n,k);
}


int main(){

    ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);

    FOR(i,2){
        P[i][0]=1;
        for(int j=1;j<mx;j++){
            P[i][j] = (P[i][j-1]*base[i])%mod[i];
        }
    }
    int t;cin>>t;
    for(int cs=1;cs<=t;cs++){
        solve(cs);
    }
    return 0;
}