#include<bits/stdc++.h>
//ATCoder Lib
// #pragma GCC optimize("Ofast")
// #pragma GCC optimize("unroll-loops")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
namespace atcoder {
 
namespace internal {
 
template <class T> struct simple_queue {
    std::vector<T> payload;
    int pos = 0;
    void reserve(int n) { payload.reserve(n); }
    int size() const { return int(payload.size()) - pos; }
    bool empty() const { return pos == int(payload.size()); }
    void push(const T& t) { payload.push_back(t); }
    T& front() { return payload[pos]; }
    void clear() {
        payload.clear();
        pos = 0;
    }
    void pop() { pos++; }
};
 
template <class E> struct csr {
    std::vector<int> start;
    std::vector<E> elist;
    explicit csr(int n, const std::vector<std::pair<int, E>>& edges)
        : start(n + 1), elist(edges.size()) {
        for (auto e : edges) {
            start[e.first + 1]++;
        }
        for (int i = 1; i <= n; i++) {
            start[i] += start[i - 1];
        }
        auto counter = start;
        for (auto e : edges) {
            elist[counter[e.first]++] = e.second;
        }
    }
};
 
}  // namespace internal
 
}
namespace atcoder {
 
template <class Cap> struct mf_graph {
  public:
    mf_graph() : _n(0) {}
    explicit mf_graph(int n) : _n(n), g(n) {}
 
    int add_edge(int from, int to, Cap cap) {
        assert(0 <= from && from < _n);
        assert(0 <= to && to < _n);
        assert(0 <= cap);
        // printf("%d %d %d\n",from,to,cap);
        int m = int(pos.size());
        pos.push_back({from, int(g[from].size())});
        int from_id = int(g[from].size());
        int to_id = int(g[to].size());
        if (from == to) to_id++;
        g[from].push_back(_edge{to, to_id, cap});
        g[to].push_back(_edge{from, from_id, 0});
        return m;
    }
 
    struct edge {
        int from, to;
        Cap cap, flow;
    };
 
    edge get_edge(int i) {
        int m = int(pos.size());
        assert(0 <= i && i < m);
        auto _e = g[pos[i].first][pos[i].second];
        auto _re = g[_e.to][_e.rev];
        return edge{pos[i].first, _e.to, _e.cap + _re.cap, _re.cap};
    }
    std::vector<edge> edges() {
        int m = int(pos.size());
        std::vector<edge> result;
        for (int i = 0; i < m; i++) {
            result.push_back(get_edge(i));
        }
        return result;
    }
    void change_edge(int i, Cap new_cap, Cap new_flow) {
        int m = int(pos.size());
        assert(0 <= i && i < m);
        assert(0 <= new_flow && new_flow <= new_cap);
        auto& _e = g[pos[i].first][pos[i].second];
        auto& _re = g[_e.to][_e.rev];
        _e.cap = new_cap - new_flow;
        _re.cap = new_flow;
    }
 
    Cap flow(int s, int t) {
        return flow(s, t, std::numeric_limits<Cap>::max());
    }
    Cap flow(int s, int t, Cap flow_limit) {
        assert(0 <= s && s < _n);
        assert(0 <= t && t < _n);
        assert(s != t);
 
        std::vector<int> level(_n), iter(_n);
        internal::simple_queue<int> que;
 
        auto bfs = [&]() {
            std::fill(level.begin(), level.end(), -1);
            level[s] = 0;
            que.clear();
            que.push(s);
            while (!que.empty()) {
                int v = que.front();
                que.pop();
                for (auto e : g[v]) {
                    if (e.cap == 0 || level[e.to] >= 0) continue;
                    level[e.to] = level[v] + 1;
                    if (e.to == t) return;
                    que.push(e.to);
                }
            }
        };
        auto dfs = [&](auto self, int v, Cap up) {
            if (v == s) return up;
            Cap res = 0;
            int level_v = level[v];
            for (int& i = iter[v]; i < int(g[v].size()); i++) {
                _edge& e = g[v][i];
                if (level_v <= level[e.to] || g[e.to][e.rev].cap == 0) continue;
                Cap d =
                    self(self, e.to, std::min(up - res, g[e.to][e.rev].cap));
                if (d <= 0) continue;
                g[v][i].cap += d;
                g[e.to][e.rev].cap -= d;
                res += d;
                if (res == up) return res;
            }
            level[v] = _n;
            return res;
        };
 
        Cap flow = 0;
        while (flow < flow_limit) {
            bfs();
            if (level[t] == -1) break;
            std::fill(iter.begin(), iter.end(), 0);
            Cap f = dfs(dfs, t, flow_limit - flow);
            if (!f) break;
            flow += f;
        }
        return flow;
    }
 
    std::vector<bool> min_cut(int s) {
        std::vector<bool> visited(_n);
        internal::simple_queue<int> que;
        que.push(s);
        while (!que.empty()) {
            int p = que.front();
            que.pop();
            visited[p] = true;
            for (auto e : g[p]) {
                if (e.cap && !visited[e.to]) {
                    visited[e.to] = true;
                    que.push(e.to);
                }
            }
        }
        return visited;
    }
 
  private:
    int _n;
    struct _edge {
        int to, rev;
        Cap cap;
    };
    std::vector<std::pair<int, int>> pos;
    std::vector<std::vector<_edge>> g;
};
 
}
using namespace atcoder;
using namespace std;
#define ll long long
inline int read(){
   int s=0,w=1;
   char ch=getchar();
   while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
   while(ch>='0'&&ch<='9') s=s*10+ch-'0',ch=getchar();
   return s*w;
}
int ri[1<<20],ci[1<<20];
bool final[1<<20];
int xxx[1<<20],yyy[1<<20];
signed main()
{
	for(int TTT=read();TTT--;)
	{
		set<pair<int,int>> R;
		set<pair<int,int>> C;
		map<int,int> mr,mc;
		map<pair<int,int>,int> ir,ic;
		int n=read(),m=read(),k=m-read();
		ll ans=0;
		for(int i=1; i<=n; ++i)
		{
			int x=read(),y=read();
			++mr[x];++mc[y];
			R.insert({x,y});
			ir[{x,y}]=i;
			C.insert({y,x});
			ic[{y,x}]=i;
		}
		for(auto [_,i]:mr) ans+=i-1;
		for(auto [_,i]:mc) ans+=i-1;
		mf_graph<int> G(n*2+3);
		int S=n*2+1,T=n*2+2;
		for(int i=1; i<=m; ++i)
		{
			int x=read(),y=read();
			xxx[i]=x,yyy[i]=y;
			auto it=R.lower_bound({x,y});
			if(it==R.end()||it==R.begin()) ri[i]=0;
			else if(it->first>x||prev(it)->first<x) ri[i]=0;
			else
			{
				ri[i]=ir[*it];
			}
			
			it=C.lower_bound({y,x});
			if(it==C.end()||it==C.begin()) ci[i]=0;
			else if(it->first>y||prev(it)->first<y) ci[i]=0;
			else
			{
				ci[i]=ic[*it];
			}
			// printf("qwq %d %d\n",ri[i],ci[i]);
			if(ri[i]&&ci[i]) G.add_edge(ri[i],ci[i]+n,1);
		}
		for(int i=1; i<=n; ++i)
			G.add_edge(S,i,1),
			G.add_edge(n+i,T,1);
		// G.flow(S,T);
		int w=G.flow(S,T);
		for(int i=1; i<=m; ++i) final[i]=1;
		auto X=G.edges();
		set<pair<int,int>> RR=R,CC=C;
		// printf("%lld\n",ans);
		for(int i=1,idx=0; i<=m; ++i) if(ri[i]&&ci[i]&&k)
		{
			int x=xxx[i],y=yyy[i];
			if(X[idx++].flow==0) continue;
			final[i]=0;
			ans-=2;--k;
			auto it=R.lower_bound({x,y});
			RR.erase(*it);
			it=C.lower_bound({y,x});
			CC.erase(*it);
		}
		for(int i=1; i<=m; ++i) if(final[i]&&k)
		{
			int x=xxx[i],y=yyy[i];
			auto it=R.lower_bound({x,y});
			if(ri[i]&&RR.count(*it))
			{
				RR.erase(*it);
				final[i]=0;
				// puts("R??");
				--ans;--k;
				continue;
			}
			it=C.lower_bound({y,x});
			if(ci[i]&&CC.count(*it))
			{
				CC.erase(*it);
				final[i]=0;
				// puts("C???");
				--ans;--k;
				continue;
			}
		}
		for(int i=1; i<=m; ++i) if(final[i]&&k) final[i]=0,--k;
		printf("%lld\n",ans);
		for(int i=1; i<=m; ++i) if(final[i]) printf("%d ",i);
		puts("");
	}
	return 0;
}