#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
using i64 = long long;
#define rep(i,a,n) for(int i=a;i<n;i++)
#define per(i,a,n) for(int i=n-1;i>=a;i--)
#define fastio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define multi int _;cin>>_;while(_--)
#define debug(x) cerr << #x << " = " << (x) << endl;
#define int long long
#define pb push_back
#define eb emplace_back
ll gcd(ll a,ll b){ return b?gcd(b,a%b):a;}
mt19937_64 mrand(chrono::steady_clock().now().time_since_epoch().count());
int rnd(int l,int r){ return mrand() % (r - l + 1) + l;}
void test() {cerr << "\n";}
template<typename T, typename... Args> 
void test(T x, Args... args) {cerr << x << " ";test(args...);}
const ll MOD = 998244353;
// const ll MOD = 1e9+7;
ll ksm(ll x,ll y){ll ans=1;x%=MOD;while(y){if(y&1)ans=ans*x%MOD;x=x*x%MOD,y/=2;}return ans;}

const int P1 = 972152273, base1 = 809;
const int P2 = 905563261, base2 = 919;
const ll N = 200005;
//head

using ll = long long;

const int V = 1010;
const int E = 101000;
template<typename T>
struct MaxFlow
{
    int s, t, vtot;
    int head[V], etot;
    int dis[V], cur[V];
    struct edge
    {
        int v, nxt;
        T f;
    }e[E * 2];
    void addedge(int u, int v, T f)
    {
        e[etot] = {v, head[u], f}; head[u] = etot++;
        e[etot] = {u, head[v], 0}; head[v] = etot++;
    }
    bool bfs()
    {
        for(int i = 1 ; i <= vtot ; i++ )
        {
            dis[i] = 0;
            cur[i] = head[i];
        }
        queue<int> q;
        q.push(s); dis[s] = 1;
        while(!q.empty())
        {
            int u = q.front(); q.pop();
            for(int i = head[u] ; ~i ; i = e[i].nxt)
            {
                if(e[i].f && !dis[e[i].v])
                {
                    int v = e[i].v;
                    dis[v] = dis[u] + 1;
                    if(v == t) return true;
                    q.push(v);
                }
            }
        }
        return false;
    }
    T dfs(int u, T m)
    {
        if(u == t) return m;
        T flow = 0;
        for(int i = cur[u]; ~i ; cur[u] = i = e[i].nxt)
        {
            if(e[i].f && dis[e[i].v] == dis[u] + 1)
            {
                T f = dfs(e[i].v, min(m, e[i].f));
                e[i].f -= f;
                e[i ^ 1].f += f;
                m -= f;
                flow += f;
                if(!m) break;
            }
        }
        if(!flow) dis[u] = -1;
        return flow;
    }
    T dinic()
    {
        T flow = 0;
        while(bfs()) flow += dfs(s, numeric_limits<T>::max());
        return flow;
    }
    void init(int s_, int t_, int vtot_ )
    {
        s = s_;
        t = t_;
        vtot = vtot_;
        etot = 0;
        for(int i = 1 ; i <= vtot ; i++ )
        {
            head[i] = -1;
        }
    } 
};

MaxFlow<ll> g;

void solve(int testcase) {
	int n;
	std::cin >> n;
	std::vector<std::pair<int, int>> a(n + 1);
	for (int i = 1; i <= n; i++) {
		int x, y;
		std::cin >> x >> y;
		a[i] = {x, y};
	}

	std::sort(a.begin() + 1, a.end());

	int m;
	std::cin >> m;
	std::vector<std::pair<int, int>> b(m + 1);
	for (int i = 1; i <= m; i++) {
		int x, y;
		std::cin >> x >> y;
		b[i] = {x, y};
	}
	std::vector<std::array<int, 4>> row, column;
	for (int i = 2; i <= n; i++) {
		if (a[i - 1].first == a[i].first) {
			if (a[i - 1].second + 1 == a[i].second) {
				std::cout << "-1\n";
				return;
			}
			for (int j = 1; j <= m; j++) {
				auto [x1, y1] = a[i - 1];
				auto [x2, y2] = a[i];
				auto [x3, y3] = b[j];
				if (x3 == x1 && y1 < y3 && y3 < y2) {
					goto OK1;
				}
			}
			row.push_back({a[i - 1].first, a[i - 1].second, a[i].first, a[i].second});
			OK1:;
		}
	}

	std::sort(a.begin() + 1, a.end(), [&](const auto &a, const auto &b) {
		if (a.second == b.second) return a.first < b.first;
		return a.second < b.second;
	});
	for (int i = 2; i <= n; i++) {
		if (a[i - 1].second == a[i].second) {
			if (a[i - 1].first + 1 == a[i].first) {
				std::cout << "-1\n";
				return;
			}
			for (int j = 1; j <= m; j++) {
				auto [x1, y1] = a[i - 1];
				auto [x2, y2] = a[i];
				auto [x3, y3] = b[j];
				if (y1 == y3 && x1 < x3 && x3 < x2) {
					goto OK2;
				}
			}
			column.push_back({a[i - 1].first, a[i - 1].second, a[i].first, a[i].second});
			OK2:;
		}
	}

	int s = row.size() + column.size() + 1;
	int t = s + 1;
	g.init(s, t, t);
    int tc=0;
	for (int i = 0; i < row.size(); i++) {
		for (int j = 0; j < column.size(); j++) {
			auto [x1, y1, x2, y2] = row[i];
			auto [x3, y3, x4, y4] = column[j];
			if (x3 < x1 && x1 < x4 && y1 < y3 && y3 < y2) {
                tc++;
				g.addedge(i + 1, row.size() + j + 1, 1);
			}
		}
	}

	for (int i = 1; i <= row.size(); i++) {
		g.addedge(s, i, 1);
	}

	for (int i = 1; i <= column.size(); i++) {
		g.addedge(row.size() + i, t, 1);
	}

	std::vector<std::pair<int, int>> res;

	int ans = g.dinic();
if(n>100) cout<<tc<<endl;
if(n<=100)
	std::cout << row.size() + column.size() - ans << "\n";

	std::vector<int> vis1(row.size()), vis2(column.size());
	for (int i = 0; i < g.etot; i += 2) {
		int u = g.e[i ^ 1].v;
		int v = g.e[i].v;
		if (u >= s || v >= s) continue;
		if (g.e[i].f == 0) {
			vis1[u - 1] = 1;
			vis2[v - 1 - row.size()] = 1;
			auto [x1, y1, x2, y2] = row[u - 1];
			auto [x3, y3, x4, y4] = column[v - 1 - row.size()];
			res.push_back({x1, y3});
		}
	}

	for (int i = 0; i < row.size(); i++) {
		if (vis1[i] == 0) {
			auto [x1, y1, x2, y2] = row[i];
			res.push_back({x1, y1 + 1});
		}
	}

	for (int i = 0; i < column.size(); i++) {
		if (vis2[i] == 0) {
			auto [x1, y1, x2, y2] = column[i];
			res.push_back({x1 + 1, y1});
		}
	}
if(n<=100)
	for (auto [x, y] : res) {
		std::cout << x << " " << y << "\n";
	}
}

signed main()
{  
#ifdef localfreopen
    // freopen("1.in","r",stdin);
#endif
    fastio
    std::cout << std::fixed << std::setprecision(10);
    int t;
    cin >> t;
    for(int i = 1 ; i <= t ; i++ )
    {
        solve(i);
    }
    return 0;
}