#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using db = double;
constexpr int mod = 998244353;
constexpr int N = 1e6 + 10;

template <class T>
struct Flow {
    T inf;
    int n;
    struct Edge {
        int v;
		T cap;
        Edge(int v, T cap) : v(v), cap(cap) {}
    };
    vector<Edge> e; // e[i] 存编号为 i 的边所指向的节点 v / 流量 cap
    vector<vector<int>> g; // g[u] 存储了所有以 u 为起点的边 u -> v 的编号 i
    vector<int> cur, deep;
    Flow(int n) : inf(numeric_limits<T>::max()), n(n), g(n + 1) {}
    bool bfs(int s, int t) {
        deep.assign(n + 1, -1);
        queue<int> q;
        deep[s] = 0;
        q.push(s);
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            for (int i : g[u]) {
                auto [v, c] = e[i];
                if (c > 0 && deep[v] == -1) {
                    deep[v] = deep[u] + 1;
                    if (v == t) return true;
                    q.push(v);
                }
            }
        }
        return false;
    }
    T dfs(int u, int t, T flow) {
        if (u == t) return flow;
        T remain = flow;
        for (int &i = cur[u]; i < (int)g[u].size(); i++) {
            int j = g[u][i];
            auto [v, c] = e[j];
            if (c > 0 && deep[v] == deep[u] + 1) {
                T cost = dfs(v, t, min(remain, c));
                e[j].cap -= cost;
                e[j ^ 1].cap += cost;
                remain -= cost;
                if (remain == 0) return flow;
            }
        }
        return flow - remain;
    }
    void add(int u, int v, T cap) {
        g[u].push_back(e.size());
        e.emplace_back(v, cap);
        g[v].push_back(e.size());
        e.emplace_back(u, 0);
    }
    // 最大流: 从源点 s 到汇点 t 的最大流量
    T max_flow(int s, int t) {
        T ans = 0;
        while (bfs(s, t)) {
            cur.assign(n + 1, 0);
            ans += dfs(s, t, inf);
        }
        return ans;
    }
    // 最小割: 分割源点 s 到汇点 t 容量和最小的割边集合，最小割 = 最大流
    vector<int> min_cut_ST() { // 标记最小割 (S, T)
        vector<int> c(n + 1);
        for (int i = 1; i <= n; i++) {
            c[i] = (deep[i] != -1); // 源点 s 可到达节点 i
        }
        return c;
    }
    struct _Edge {
        int u, v;
        T cap;
        T flow;
    };
    vector<_Edge> edges() {
        vector<_Edge> t;
        for (int i = 0; i < e.size(); i += 2) {
            _Edge x;
            x.u = e[i + 1].v;
            x.v = e[i].v;
            x.cap = e[i].cap + e[i + 1].cap;
            x.flow = e[i + 1].cap;
            t.push_back(x);
        }
        return t;
    }
};
void solve() {
    int n; cin >> n;
    map<int, vector<int>> rp, cp;
    vector<int> r(n + 1), c(n + 1);
    // 每一行 / 每一列 维护坐标
    for (int i = 1; i <= n; i++) {
        cin >> r[i] >> c[i];
        rp[r[i]].push_back(c[i]);
        cp[c[i]].push_back(r[i]);
    }
    int m; cin >> m;
    for (int i = 1; i <= m; i++) {
        int x, y; cin >> x >> y;
        rp[x].push_back(y);
        cp[y].push_back(x);
    }
    for (auto &[x, y] : rp) sort(y.begin(), y.end());
    for (auto &[x, y] : cp) sort(y.begin(), y.end());
    // 枚举两车位置关系，如果相邻 则无解，如果碰撞 则创建新的碰撞线段
    vector<array<int, 3>> rline, cline;
    for (int i = 1; i <= n; i++) {
        for (int j = i + 1; j <= n; j++) {
            if (r[i] == r[j]) {
                if (abs(c[i] - c[j]) == 1) {
                    cout << "-1\n";
                    return;
                }
                auto &v = rp[r[i]];
                auto it = lower_bound(v.begin(), v.end(), c[i]);
                if ((it != v.begin() && *prev(it) == c[j]) || (it != v.end() && *next(it) == c[j])) {
                    rline.push_back({r[i], min(c[i], c[j]), max(c[i], c[j])});
                }
            }
            if (c[i] == c[j]) {
                if (abs(r[i] - r[j]) == 1) {
                    cout << "-1\n";
                    return;
                }
                auto &v = cp[c[i]];
                auto it = lower_bound(v.begin(), v.end(), r[i]);
                if ((it != v.begin() && *prev(it) == r[j]) || (it != v.end() && *next(it) == r[j])) {
                    cline.push_back({c[i], min(r[i], r[j]), max(r[i], r[j])});
                }
            }
        }
    }
    // 对于行列碰撞的交点 (x, y)，建立 行碰撞线段 -> 列碰撞线段 的有向边，容量为 1，跑最大流即可
    int numr = rline.size(), numc = cline.size();
    Flow<int> f(numr + numc + 2);
    int S = numr + numc + 1, T = numr + numc + 2;
    for (int i = 1; i <= numr; i++) f.add(S, i, 1);
    for (int i = 1; i <= numc; i++) f.add(numr + i, T, 1);
    for (int i = 1; i <= numr; i++) {
        for (int j = 1; j <= numc; j++) {
            auto [x, y1, y2] = rline[i - 1];
            auto [y, x1, x2] = cline[j - 1];
            if (x1 < x && x < x2 && y1 < y && y < y2) {
                // cerr << i << ' ' << j << "\n";
                // cerr << x << ' ' << y1 << ' ' << y2 << ' ' << y << ' ' << x1 << ' ' << x2 << "\n";
                f.add(i, numr + j, 1);
            }
        }
    }
    // 处理行列碰撞线段 and 对应的放置方案
    f.max_flow(S, T);
    auto e = f.edges();
    set<pair<int, int>> vis;
    vector<pair<int, int>> ans;
    for (auto [u, v, cap, flow] : e) {
        if (u == S || v == T) continue;
        if (flow == 1) {
            auto [x, y1, y2] = rline[u - 1];
            auto [y, x1, x2] = cline[v - numr - 1];
            ans.emplace_back(x, y);
            vis.insert({x, y1 + 1});
            vis.insert({x1 + 1, y});
        }
    }
    for (auto [x, y1, y2] : rline) {
        if (!vis.count({x, y1 + 1})) {
            ans.emplace_back(x, y1 + 1);
        }
    }
    for (auto [y, x1, x2] : cline) {
        if (!vis.count({x1 + 1, y})) {
            ans.emplace_back(x1 + 1, y);
        }
    }
    cout << ans.size() << "\n";
    for (auto [x, y] : ans) cout << x << ' ' << y << "\n";
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int tt = 1;
    cin >> tt;
    while (tt--) {
        solve();
    }
    return 0;
}