#include <bits/stdc++.h>

#define debug(...) 42;
#ifdef LOCAL
#include "debug.h"
#endif

using namespace std;
#define fi first
#define se second
#define pb push_back
#define ll long long
#define ull unsigned long long
#define pii pair<int, int>
#define all(a) a.begin(), a.end()
template<typename T> bool setmin(T &a, T b) { return (a > b ? a = b, 1 : 0); }
template<typename T> bool setmax(T &a, T b) { return (a < b ? a = b, 1 : 0); }

void solve(){
    int n; cin >> n;
    map<int, vector<int>> rowA, colA;
    map<int, vector<int>> rowB, colB;

    for(int i = 0; i < n; i++){
        int r, c; cin >> r >> c;
        rowA[r].push_back(c);
        colA[c].push_back(r);
    }

    map<pii, int> ob;
    int m; cin >> m;
    for(int i = 0; i < m; i++){
        int r, c; cin >> r >> c;
        rowB[r].push_back(c);
        colB[c].push_back(r);
        ob[{r, c}] = 1;
    }

    int id = 0, L = 0;
    map<int, int> to;
    map<pii, int> belx;
    map<pii, int> bely;
    for(auto&[r, posx]: rowA){
        sort(all(posx));
        int num = posx.size();
        for(int i = 0; i < num - 1; i++){
            to[++id] = r;
            belx[{posx[i], posx[i + 1]}] = id;
        }
    }

    L = id;
    
    for(auto&[c, posy]: colA){
        sort(all(posy));
        int num = posy.size();
        for(int i = 0; i < num - 1; i++){
            to[++id] = c;
            bely[{posy[i], posy[i + 1]}] = id;
        }
    }

    vector<vector<int>> adj(L + 1);

    for(auto&[r, posx]: rowA){
        int numx = posx.size();
        for(int i = 0; i < numx - 1; i++){
            if(posx[i] + 1 == posx[i + 1]){
                cout << -1 << '\n';
                return;
            }
            auto it = upper_bound(all(rowB[r]), posx[i]);
            int posr = posx[i + 1];
            if(it == rowB[r].end() or *it > posr){
                for(auto&[c, posy]: colA){
                    int numy = posy.size();
                    for(int j = 0; j < numy - 1; j++){
                        if(posy[j] + 1 == posy[j + 1]){
                            cout << -1 << '\n';
                            return;
                        }
                        auto it2 = upper_bound(all(colB[c]), posy[j]);
                        int posr2 = posy[j + 1];
                        if(it2 == colB[c].end() or *it2 > posr2){
                            if(!ob.count({r, c}) and posy[j] < r and posy[j + 1] > r and posx[i] < c and posx[i + 1] > c){
                                int u = belx[{posx[i], posx[i + 1]}];
                                int v = bely[{posy[j], posy[j + 1]}];
                                assert(u < v);
                                adj[u].push_back(v);
                            }
                        }
                    }
                }
            }
        }
    }

    vector<int> st(id + 1), match(id + 1);
    function<bool(int)> find = [&](int u){
        for(int v: adj[u]){
            if(!st[v]){
                st[v] = true;
                if(match[v] == 0 or find(match[v])){
                    match[v] = u;
                    return true;
                }
            }
        }
        return false;
    };

    for(int i = 1; i <= L; i++){
        st.assign(id + 1, false);
        find(i);
    }

    vector<pii> ans;
    for(int u = L + 1; u <= id; u++){
        if(match[u]){
            int r = to[match[u]];
            int c = to[u];
            rowB[r].push_back(c);
            colB[c].push_back(r);
            ans.push_back({r, c});
        }
    }

    // debug(ans);

    for(auto&[_, vec]: rowB){
        sort(all(vec));
    }
    for(auto&[_, vec]: colB){
        sort(all(vec));
    }

    for(auto&[r, vec]: rowA){
        int num = vec.size();
        for(int i = 0; i < num - 1; i++){
            auto it = upper_bound(all(rowB[r]), vec[i]);
            int posr = vec[i + 1];
            if(it == rowB[r].end() or *it > posr){
                ans.push_back({r, vec[i] + 1});
            }
        }
    }

    for(auto&[c, vec]: colA){
        int num = vec.size();
        for(int i = 0; i < num - 1; i++){
            auto it = upper_bound(all(colB[c]), vec[i]);
            int posr = vec[i + 1];
            if(it == colB[c].end() or *it > posr){
                ans.push_back({vec[i] + 1, c});
            }
        }
    }

    cout << ans.size() << '\n';
    for(auto[x, y]: ans){
        cout << x << ' ' << y << '\n';
    }
}

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

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