#include <bits/stdc++.h>
using namespace std;
const int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
void solve()
{
    int n;
    cin >> n;
    map<int, set<int>> mpx, mpy, mpxo, mpyo;
    using P = pair<int, int>;
    vector<P> poi(n);
    set<int> dx, dy;
    for (auto &[x, y] : poi)
    {
        cin >> x >> y;
        mpx[x].insert(y);
        mpy[y].insert(x);
        dx.insert(x);
        dy.insert(y);
    }

    int m;
    cin >> m;
    vector<P> obs(m);
    map<P, int> sid;
    map<P, P> edge_p;
    for (auto &[x, y] : obs)
    {
        cin >> x >> y;
        mpxo[x].insert(y);
        mpyo[y].insert(x);
    }


    map<P, int> ids;
    for (int i = 0; i < n; i++)
        ids[poi[i]] = i;
    vector g(n + 1, vector<int>());
    int icnt = 0;
    set<int> xids, yids;
    auto getcnts = [&](int x, int y)
    {
        auto nxty = mpx[x].lower_bound(y);
        int ly = 0, ry = 1e9;
        int cntx = 1, cnty = 1;
        if (nxty == mpx[x].begin() || nxty == mpx[x].end())
            cntx = 0;
        if (cntx)
        {
            auto prey = prev(nxty);
            if (nxty == mpx[x].begin())
                prey = mpx[x].end();
            if (nxty != mpx[x].end())
                ry = *nxty;
            if (prey != mpx[x].end())
                ly = *prey;
        }

        auto nxtx = mpy[y].lower_bound(x);
        if (nxtx == mpy[y].end() || nxtx == mpy[y].begin())
            cnty = 0;
        int lx = 0, rx = 1e9;
        if (cnty)
        {
            auto prex = prev(nxtx);
            if (nxtx == mpy[y].begin())
                prex = mpy[y].end();
            if (nxtx != mpy[y].end())
                rx = *nxtx;
            if (prex != mpy[y].end())
                lx = *prex;
        }
        auto oby = mpxo[x].lower_bound(ly);
        if (oby != mpxo[x].end())
        {
            int p = *oby;
            if (ly < p && p < ry)
                cntx = 0;
        }
        auto obx = mpyo[y].lower_bound(lx);
        if (obx != mpyo[y].end())
        {
            int p = *obx;
            if (lx < p && p < rx)
                cnty = 0;
        }
        if (cntx + cnty == 2)
        {
            auto &xid = sid[minmax(ids[P(x, ly)], ids[P(x, ry)])];
            auto &yid = sid[minmax(ids[P(lx, y)], ids[P(rx, y)])];
            if (!xid)
                xid = ++icnt;
            if (!yid)
                yid = ++icnt;
            xids.insert(xid);
            yids.insert(yid);
            g[xid].push_back(yid);
            g[yid].push_back(xid);
            edge_p[minmax(xid, yid)] = P(x, y);
        }
        return cntx + cnty;
    };
    for (auto x : dx)
    {
        for (auto y : dy)
        {
            if (mpx[x].contains(y) || mpxo[x].contains(y))
                continue;
            int w = getcnts(x, y);
        }
    }
    vector<P> ans;
    vector<int> xx(n * 2 + 1, -1), yy(n * 2 + 1, -1);
    vector<bool> vis(n * 2 + 1);
    auto dfs = [&](auto &self, int u) -> bool
    {
        for (auto v : g[u])
        {
            if (vis[v])
                continue;
            vis[v] = 1;
            if (yy[v] == -1 || self(self, yy[v]))
            {
                yy[v] = u;
                xx[u] = v;
                return true;
            }
        }
        return false;
    };
    {
        for (auto x : xids)
        {
            vis.assign(n * 2 + 1, 0);
            dfs(dfs, x);
        }
    };

    for (auto x : xids)
    {
        if (xx[x] != -1)
        {
            auto [ox, oy] = edge_p[minmax(x, xx[x])];
            mpxo[ox].insert(oy);
            mpyo[oy].insert(ox);
            ans.push_back(P(ox, oy));
        }
    }
    bool fuck = true;
    for (auto [x, y] : poi)
    {
        for (int i = 0; i < 4; i++)
        {
            auto [nx, ny] = P(x + dir[i][0], y + dir[i][1]);
            if (mpx[nx].contains(ny))
            {
                fuck = false;
                break;
            }
            if (mpxo[nx].contains(ny))
                continue;
            if (getcnts(nx, ny))
            {
                mpxo[nx].insert(ny);
                mpyo[ny].insert(nx);
                ans.push_back(P(nx, ny));
            }
        }
    }
    if (fuck)
    {
        cout << ans.size() << '\n';
        for (auto [x, y] : ans)
            cout << x << ' ' << y << '\n';
    }
    else
    {
        cout << -1 << '\n';
    }
}

int main()
{
#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
    auto _ = clock();
#endif
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    cin >> T;
    while (T--)
        solve();
#ifdef LOCAL
    cerr << clock() - _ << '\n';
#endif
    return 0;
}