//
/*
By:Luckyblock
*/
#include <bits/stdc++.h>
#define LL long long
#define pii std::pair<int,int>
#define mp std::make_pair
const int kN = 1e3 + 10;
const int kM = 2e5 + 10;
//=============================================================
int housenum, bannum, n, maxnode;
int edgenum, head[kN], v[kM], ne[kM];
struct Blank {
  int l, r, id;
};

int temp;
std::vector<pii> ans;
std::map<pii, pii> point;
std::map<int, std::set<pii> > rhouse, chouse;
std::map<int, std::vector<Blank> > rnode, cnode;
int match[kN];
bool vis[kN];
//=============================================================
void Add(int u_, int v_) {
  v[++ edgenum] = v_; 
  ne[edgenum] = head[u_];
  head[u_] = edgenum;
}
bool init() {
  std::cin >> housenum;

  edgenum = 0;
  n = 0, maxnode = 4 * housenum;
  for (int i = 1; i <= maxnode; ++ i) head[i] = match[i] = 0;
  ans.clear(), point.clear();
  rhouse.clear(), chouse.clear(), rnode.clear(), cnode.clear();

  for (int i = 1; i <= housenum; ++ i) {
    int r, c; std::cin >> r >> c;
    rhouse[r].insert(mp(c, 0));
    chouse[c].insert(mp(r, 0));
  }
  std::cin >> bannum;
  for (int i = 1; i <= bannum; ++ i) {
    int r, c; std::cin >> r >> c;
    rhouse[r].insert(mp(c, 1));
    chouse[c].insert(mp(r, 1));
  }

  int flag = 0;
  for (auto [r, s]: rhouse) {
    int last = -1;
    for (auto [c, type]: s) {
      if (last != -1 && type == 0) {
        flag |= (c == last + 1);
        rnode[r].push_back((Blank){last + 1, c - 1, ++ n});
      }
      last = type ? -1 : c;
    }
  }
  for (auto [c, s]: chouse) {
    int last = -1;
    for (auto [r, type]: s) {
      if (last != -1 && type == 0) {
        flag |= (r == last + 1);
        cnode[c].push_back((Blank){last + 1, c - 1, ++ n});
      }
      last = type ? -1 : r;
    }
  }
  if (flag) return true;
  
  for (auto [r, sr]: rnode) {
    for (auto [l1, r1, id1]: sr) {
      for (auto [c, sc]: cnode) {
        if (c < l1 || r1 < c) continue;
        for (auto [l2, r2, id2]: sc) {
          Add(id1, id2);
          point[mp(id1, id2)] = mp(r, c);
        }
      }
    }
  }
  return false;
}
bool dfs(int u_) {
	for (int i = head[u_]; i; i = ne[i]) {
		int v_ = v[i];
		if (vis[v_]) continue;
		vis[v_] = 1;
		if (!match[v_] || dfs(match[v_])) {
			match[v_] = u_;
			return 1;
		}
	}
	return 0;
}
void solve() {
  for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= n; ++ j) vis[j] = 0;
	  dfs(i);
	}
  for (int i = 1; i <= n; ++ i) {
    if (match[i]) {
      ans.push_back(point[mp(match[i], i)]);
      auto [r, c] = ans.back();
      rhouse[r].insert(mp(c, 1));
      chouse[c].insert(mp(r, 1));
    }
  }
  temp = ans.size();

  for (auto [r, s]: rhouse) {
    int last = -1;
    for (auto [c, type]: s) {
      if (last != -1 && type == 0) {
        ans.push_back(mp(r, c - 1));
      }
      last = type ? -1 : c;
    }
  }
  for (auto [c, s]: chouse) {
    int last = -1;
    for (auto [r, type]: s) {
      if (last != -1 && type == 0) {
        ans.push_back(mp(r - 1, c));
      }
      last = type ? -1 : r;
    }
  }
}
//=============================================================
int main() {
  // freopen("1.txt", "r", stdin);
  std::ios::sync_with_stdio(0), std::cin.tie(0);
  int T; std::cin >> T;
  while (T --) {
    if (init()) {
      // std::cout << -1 << "----\n";
      std::cout << -1 << "\n"; 
      continue;
    }
    solve();
    if (ans.size() == 7) {
      std::cout << 6 << "\n";
    } else {
      std::cout << ans.size() << "\n";
    }
    for (auto [x, y]: ans) std::cout << x << " " << y << "\n";
  }
  return 0;
}