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

template <class T> struct simple_queue {
	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 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);
		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};
	}
	vector<edge> edges() {
		int m = int(pos.size());
		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, 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);

		vector<int> level(_n), iter(_n);
		simple_queue<int> que;

		auto bfs = [&]() {
			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, 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;
			fill(iter.begin(), iter.end(), 0);
			Cap f = dfs(dfs, t, flow_limit - flow);
			if (!f) break;
			flow += f;
		}
		return flow;
	}

	vector<bool> min_cut(int s) {
		vector<bool> visited(_n);
		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;
	};
	vector<pair<int, int>> pos;
	vector<vector<_edge>> g;
};

void solve() {
	int n, m, k;
	cin >> n >> m >> k;
	map<int, vector<array<int, 3>>> row, col;
	while (n--) {
		int r, c;
		cin >> r >> c;
		row[r].push_back({c, -1, -1});
		col[c].push_back({r, -1, -1});
	}
	for (int i = 0; i < m; i++) {
		int r, c;
		cin >> r >> c;
		row[r].push_back({c, i, i});
		col[c].push_back({r, i, i});
	}
	for (auto &[_, v] : row) {
		sort(v.begin(), v.end());
		for (int i = 1; i < v.size(); i++) {
			if (v[i][2] != -1 && v[i - 1][2] != -1) {
				v[i][2] = v[i - 1][2];
			}
		}
		for (int i = v.size() - 1; i >= 0; i--) {
			if (v[i][2] == v[0][2] || v[i][2] == v.back()[2]) {
				v[i][2] = -1;
			}
		}
	}
	for (auto &[_, v] : col) {
		sort(v.begin(), v.end());
		for (int i = 1; i < v.size(); i++) {
			if (v[i][2] != -1 && v[i - 1][2] != -1) {
				v[i][2] = v[i - 1][2];
			}
		}
		for (int i = v.size() - 1; i >= 0; i--) {
			if (v[i][2] == v[0][2] || v[i][2] == v.back()[2]) {
				v[i][2] = -1;
			}
		}
	}
	mf_graph<int> g(2 * m + 2);
	int s = 2 * m, t = s + 1;
	for (int i = 0; i < m; i++) {
		g.add_edge(s, i, 1);
		g.add_edge(i + m, t, 1);
	}
	vector<int> edge_id(m, -1);
	for (auto [r, v] : row) {
		for (auto [c, id, lst] : v) {
			if (id != -1 && lst != -1) {
				auto it = lower_bound(col[c].begin(), col[c].end(), array{r, -1, -1});
				if (it->at(2) != -1) {
					edge_id[id] = g.add_edge(lst, it->at(2) + m, 1);
				}
			}
		}
	}
	g.flow(s, t);
	vector<int> del;
	vector<bool> mark(m);
	for (int i = 0; i < m; i++) {
		if (edge_id[i] != -1 && g.get_edge(edge_id[i]).flow) {
			mark[i] = 1;
		}
	}
	for (const auto &foo : {row, col}) {
		for (auto &[_, v] : foo) {
			for (int i = 0; i < v.size(); i++) {
				if (v[i][1] != -1 && v[i][1] == v[i][2]) {
					bool flag = 0;
					for (int j = i; j < v.size() && v[i][2] == v[j][2]; j++) {
						if (mark[v[j][1]]) {
							flag = 1;
						}
					}
					if (!flag) {
						for (int j = i + 1; j < v.size() && v[i][2] == v[j][2]; j++) {
							del.push_back(v[j][1]);
						}
					}
				}
			}
		}
	}
	auto del1 = del;
	for (const auto &foo : {row, col}) {
		for (auto &[_, v] : foo) {
			for (int i = 0; i < v.size(); i++) {
				if (v[i][1] != -1 && v[i][1] == v[i][2]) {
					bool flag = 0;
					for (int j = i; j < v.size() && v[i][2] == v[j][2]; j++) {
						if (mark[v[j][1]]) {
							flag = 1;
						}
					}
					if (!flag) {
						del.push_back(v[i][1]);
					}
				}
			}
		}
	}
	sort(del.begin(), del.end());
	vector<int> ndel;
	for (int i = 0; i < m; i++) {
		if (!mark[i] && !binary_search(del.begin(), del.end(), i)) {
			ndel.push_back(i);
		}
	}
	del.insert(del.begin() + del1.size(), ndel.begin(), ndel.end());
	for (int i = 0; i < m; i++) {
		if (mark[i]) {
			del.push_back(i);
		}
	}
	mark.assign(m, 0);
	for (int i = 0; i < k; i++) {
		mark[del[i]] = 1;
	}
	int ans = 0;
	for (auto [_, v] : row) {
		int lst = 0;
		for (auto [foo, id, bar] : v) {
			if (id == -1) {
				if (lst == -1) {
					ans++;
				}
				lst = -1;
			} else if (!mark[id]) {
				lst = id;
			}
		}
	}
	for (auto [_, v] : col) {
		int lst = 0;
		for (auto [foo, id, bar] : v) {
			if (id == -1) {
				if (lst == -1) {
					ans++;
				}
				lst = -1;
			} else if (!mark[id]) {
				lst = id;
			}
		}
	}
	cout << ans << "\n";
	for (int i = 0; i < k; i++) {
		cout << del[i] + 1 << " \n"[i + 1 == k];
	}
}

int main() {
	ios::sync_with_stdio(0), cin.tie(0);
	int T;
	cin >> T;
	while (T--) {
		solve();
	}
	return 0;
}