#include<bits/stdc++.h>
using std::cin;
using std::cout;
using std::vector;
#define rep(i,j,k) for(int i=int(j); i<int(k); i++)
#define REP(i,j,k) for(int i=int(j); i<=int(k); i++)
#define per(i,j,k) for(int i=int(j); i>=int(k); i--)
#define ln "\n"
#define all(a) a.begin(),a.end()
#define pb emplace_back
using ll = long long;
using vi = vector<ll>;
using vii = vector<vi>;

//max_flow
template<typename T>
struct max_flow{
    struct Edge{
        int to;
        T cap;
        int rev;
    };
    int N;
    vector<vector<Edge>> edge;
    vector<int> dist, itr;
    max_flow(vii e, vii w){
        N = e.size();
        edge.resize(N);
        rep(i,0,N){
            rep(j,0,e[i].size()){
                edge[i].pb((Edge){(int)e[i][j],(T)w[i][j],(int)edge[e[i][j]].size()});
                edge[e[i][j]].pb((Edge){i,0,(int)edge[i].size()-1});
            }
        }
    }
    void bfs(int s){
        dist.assign(N,-1);
        std::queue<int> que;
        dist[s] = 0;
        que.push(s);
        while(!que.empty()){
            int now = que.front(); que.pop();
            for(auto p: edge[now]){
                int next = p.to;
                if(p.cap > 0 && dist[next] < 0){
                    dist[next] = dist[now]+1;
                    que.push(next);
                }
            }
        }
    }
    T dfs(int now, int t, T f){
        if(now == t) return f;
        for(; itr[now]<edge[now].size(); itr[now]++){
            Edge& p = edge[now][itr[now]];
            if(p.cap>0 && dist[now]<dist[p.to]){
                T mem = dfs(p.to,t,std::min(f,p.cap));
                if(mem > 0){
                    p.cap -= mem;
                    edge[p.to][p.rev].cap += mem;
                    return mem;
                }
            }
        }
        return 0;
    }
    T Query(int s, int t){
        T ret = 0;
        while(true){
            bfs(s);
            if(dist[t] < 0) break;
            itr.assign(N,0);
            while(true){
                int mem = dfs(s,t,(1ll<<30));
                if(mem <= 0) break;
                ret += mem;
            }
        }
        return ret;
    }
};

void solve(){
    ll N,M,K; cin >> N >> M >> K;
    std::map<ll,std::map<ll,ll>> r,c;
    rep(i,0,N){
        ll R,C; cin >> R >> C;
        r[R][C] = c[C][R] = i;
    }
    vi r_o(M, -1), c_o(M, -1);
    rep(i,0,M){
        ll R,C; cin >> R >> C;
        if(r.count(R)){
            auto itr = r[R].lower_bound(C);
            if(itr != r[R].end() && itr != r[R].begin()){
                itr--;
                r_o[i] = (*itr).second;
            }
        }
        if(c.count(C)){
            auto itr = c[C].lower_bound(R);
            if(itr != c[C].end() && itr != c[C].begin()){
                itr--;
                c_o[i] = (*itr).second;
            }
        }
    }
    vii edge(2*N+2), weight(2*N+2);
    ll s = 2*N, t = 2*N+1;
    rep(i,0,N){
        edge[s].pb(i);
        weight[s].pb(1);
        edge[i+N].pb(t);
        weight[i+N].pb(1);
    }

    std::map<ll,std::map<ll,ll>> mem;

    rep(i,0,M){
        if(r_o[i] != -1 && c_o[i] != -1){
            edge[r_o[i]].pb(c_o[i]+N);
            weight[r_o[i]].pb(1);
            mem[r_o[i]][c_o[i]+N] = i;
        }
    }

    max_flow<ll> mf(edge,weight);
    K = M-K;
    ll curr = mf.Query(s,t);

    vector<bool> isused(M), iscovered(2*N);

    rep(i,0,N){
        for(auto p: mf.edge[i]){
            if(N <= p.to && p.to < 2*N && p.cap == 0){
                isused[mem[i][p.to]] = true;
            }
        }
    }

    {
        for(auto p: mf.edge[s]){
            if(0 <= p.to && p.to < N && p.cap == 0){
                iscovered[p.to] = true;
            }
        }
    }

    rep(i,N,2*N){
        for(auto p: mf.edge[i]){
            if(p.to == t && p.cap == 0){
                iscovered[i] = true;
            }
        }
    }

    rep(i,0,M){
        if(curr <= K) break;
        if(isused[i]){
            iscovered[r_o[i]] = false;
            iscovered[c_o[i]+N] = false;
            isused[i] = false;
            curr--;
        }
    }

    rep(i,0,M){
        if(curr >= K) break;
        if(isused[i]) continue;
        if(r_o[i] != -1 && !iscovered[r_o[i]]){
            iscovered[r_o[i]] = true;
            isused[i] = true;
            curr++;
        }
        else if(c_o[i] != -1 && !iscovered[c_o[i]+N]){
            iscovered[c_o[i]+N] = true;
            isused[i] = true;
            curr++;
        }
    }

    rep(i,0,M){
        if(curr >= K) break;
        if(!isused[i]){
            isused[i] = true;
            curr++;
        }
    }

    ll ans = 2*N-r.size()-c.size();
    rep(i,0,2*N){
        ans -= iscovered[i];
    }
    cout << ans << ln;
    rep(i,0,M){
        if(!isused[i]) cout << i+1 << " ";
    }
    cout << ln;
}
int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    ll T; cin >> T;
    while(T--){
        solve();
    }
}