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

constexpr int inf = (1 << 30) - 1;

vector<int> hopcroft_karp(int L, int R, const vector<int>& G, const vector<int>& start) {
    // for (const auto& v : G) {
    //     for (int x : v) {
    //         cerr << x << ' ';
    //     }
    //     cerr << endl;
    // }
    vector<int> match(L + R, -1);
    vector<int> d(L, inf);
    vector<int> que(L);
    int que_l = 0, que_r = 0;
    while (true) {
        ranges::fill(d, inf);
        que_l = que_r = 0;
        for (int i = 0; i < L; ++i) {
            if (match[i] == -1) {
                d[i] = 0;
                que[que_r++] = i;
            }
        }
        while (que_l != que_r) {
            int u = que[que_l++];
            for (int e = start[u]; e < start[u + 1]; ++e) {
                const int i = G[e];
                if (match[i] != -1 && d[match[i]] == inf) {
                    d[match[i]] = d[u] + 1;
                    que[que_r++] = match[i];
                }
            }
        }
        bool fin = true;
        vector<bool> vis(L);
        auto dfs = [&](auto&& self, int v) -> bool {
            vis[v] = true;
            for (int e = start[v]; e < start[v + 1]; ++e) {
                const int i = G[e];
                if (match[i] == -1 || (d[match[i]] - d[v] == 1 && !vis[match[i]] && self(self, match[i]))) {
                    match[i] = v;
                    match[v] = i;
                    fin = false;
                    return true;
                }
            }
            return false;
        };
        for (int i = 0; i < L; ++i) {
            if (!vis[i] && match[i] == -1) {
                dfs(dfs, i);
            }
        }
        if (fin) break;
    }
    return match;
}

void solve() {
    int N, M, K;
    cin >> N >> M >> K;
    K = M - K;
    map<int, vector<pair<int, int>>> xtoy, ytox;
    for (int i = 0; i < N; ++i) {
        int x, y;
        cin >> x >> y;
        xtoy[x].emplace_back(y, i);
        ytox[y].emplace_back(x, i);
    }
    vector<bool> is_target(2 * N);
    for (auto &[x, v] : xtoy) {
        ranges::sort(v);
        for (int i = 1; i < (int)v.size(); ++i) {
            is_target[v[i].second + 0] = true;
        }
    }
    for (auto &[y, v] : ytox) {
        ranges::sort(v);
        for (int i = 1; i < (int)v.size(); ++i) {
            is_target[v[i].second + N] = true;
        }
    }
    vector<pair<int, int>> csr_es;
    csr_es.reserve(M);
    // vector<vector<int>> graph(N);
    map<pair<int, int>, int> edges;
    vector<int> prevent(2 * N, -1);
    vector<int> U(M), V(M);
    for (int i = 0; i < M; ++i) {
        int a, b;
        cin >> a >> b;
        int u = -1, v = -1;
        if (const auto itr = xtoy.find(a); itr != end(xtoy)) {
            const auto vec = itr->second;
            const auto itr2 = lower_bound(begin(vec), end(vec), pair(b, -1));
            if (itr2 != begin(vec) && itr2 != end(vec)) {
                u = itr2->second + 0;
            }
        }
        if (const auto itr = ytox.find(b); itr != end(ytox)) {
            const auto vec = itr->second;
            const auto itr2 = lower_bound(begin(vec), end(vec), pair(a, -1));
            if (itr2 != begin(vec) && itr2 != end(vec)) {
                v = itr2->second + N;
            }
        }
        if (u == -1) swap(u, v);
        if (u != -1) {
            if (v != -1) {
                csr_es.push_back(minmax(u, v));
                edges[minmax(u, v)] = i;
                prevent[u] = i;
                prevent[v] = i;
            } else {
                prevent[u] = i;
            }
        }
        U[i] = u;
        V[i] = v;
    }
    vector<int> start(N + 1);
    for (const auto& [u, v] : csr_es) {
        start[u] += 1;
    }
    for (int i = 0; i < N; ++i) {
        start[i + 1] += start[i];
    }
    vector<int> graph(start[N]);
    for (const auto& [u, v] : csr_es) {
        graph[--start[u]] = v;
    }
    const auto matching = hopcroft_karp(N, N, graph, start);
    vector<int> good;
    for (int i = 0; i < N; ++i) {
        if (const int j = matching[i]; j != -1) {
            const int e = edges[minmax(i, j)];
            good.push_back(e);
            // cerr << "Yay" << endl;
        }
    }

    if ((int)good.size() > K) {
        good.resize(K);
    }
    vector<bool> prevented(2 * N);
    vector<bool> used(M);
    for (const int e : good) {
        used[e] = true;
        for (const int x : {U[e], V[e]}) if (x != -1) {
            prevented[x] = true;
        }
    }
    for (int i = 0; i < 2 * N; ++i) {
        if (const int e = prevent[i]; !prevented[i] && e != -1 && (int)good.size() < K) {
            prevented[i] = true;
            used[e] = true;
            good.push_back(e);
        }
    }

    int remain = K - (int)good.size();
    for (int i = 0; i < M; ++i) {
        if (remain > 0 && !used[i]) {
            remain -= 1;
            used[i] = true;
        }
    }
    int ans = 0;
    for (int i = 0; i < 2 * N; ++i) {
        if (is_target[i] && !prevented[i]) {
            ans += 1;
        }
    }
    cout << ans << '\n';
    vector<int> removed;
    for (int i = 0; i < M; ++i) {
        if (!used[i]) {
            removed.push_back(i);
        }
    }
    for (int i = 0; i < (int)removed.size(); ++i) {
        cout << removed[i] + 1 << " \n"[i == (int)removed.size() - 1];
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;
    while (T--) {
        solve();
    }

    return 0;
}

/*

1
8 6 4
1 3
2 1
2 6
4 1
4 7
6 1
6 3
6 6
2 3
3 1
4 3
4 6
5 2
6 4


*/