#include<bits/stdc++.h>
using namespace std;

#define ll long long
#define PLL pair<ll,ll>
ll t,n,m;
struct node
{
    ll r,c;
    bool tag;//0为城堡 1为障碍物
};
struct seg
{
    node l,r;
};
struct pair_hash {
    template <class T1, class T2>
    size_t operator () (const pair<T1,T2> &p) const {
        auto h1 = hash<T1>{}(p.first);
        auto h2 = hash<T2>{}(p.second);
        return h1 ^ h2; // 哈希组合
    }
};
struct op{
    ll id,val;
    bool operator<(const op& a)const{
        return this->val > a.val;
    }
};

vector<node> row[510],col[510],res;
vector<seg> sg;
ll cnt_r,cnt_c;
unordered_map<ll,ll> hr,hc;
bool st[1010];
bool ok=true;
ll h[1010],ne[1010*2],e[1010*2],idx,di[1010];

bool cmp_r(node a,node b){
    return a.c<b.c;
}

bool cmp_c(node a,node b){
    return a.r<b.r;
}

void add(ll a,ll b){
    e[idx]=b,ne[idx]=h[a],h[a]=idx++;
}

node intersect(seg a,seg b){
    if(a.l.r==a.r.r&&b.l.r==b.r.r) return{0,0,0};
    if(a.l.c==a.r.c&&b.l.c==b.r.c) return{0,0,0};
    //a 列 b 行
    if(a.l.c==a.r.c&&b.l.r==b.r.r){
        a.l.r++,a.r.r--,b.l.c++,b.r.c--;
        //if(a.l.r-a.r.r==1||b.l.c-b.r.c==1) return{0,0,0};
        if(a.l.c<b.l.c||a.l.c>b.r.c) return{0,0,0};
        if(b.l.r<a.l.r||b.l.r>a.r.r) return{0,0,0};
        return{b.l.r,a.l.c,0};
    }
    //a 行 b 列
    if(a.l.r==a.r.r&&b.l.c==b.r.c){
        a.l.c++,a.r.c--,b.l.r++,b.l.r--;
        //if(b.l.r-b.r.r==1||a.l.c-a.r.c==1) return{0,0,0};
        if(b.l.c<a.l.c||b.l.c>a.r.c) return{0,0,0};
        if(a.l.r<b.l.r||a.l.r>b.r.r) return{0,0,0};
        return{a.l.r,b.l.c,0};
    }
    return{0,0,0};
}

void init(){
    //城堡
    cin>>n;
    for(int i=1;i<=n;i++){
        ll r,c;
        cin>>r>>c;
        //行
        if(!hr.count(r)){
            hr[r]=++cnt_r;
            row[hr[r]].push_back({r,c,0});
        }
        else{
            row[hr[r]].push_back({r,c,0});
        }

        //列
        if(!hc.count(c)){
            hc[c]=++cnt_c;
            col[hc[c]].push_back({r,c,0});
        }
        else{
            col[hc[c]].push_back({r,c,0});
        }
    }

    //障碍物
    cin>>m;
    for(int i=1;i<=m;i++){
        ll r,c;
        cin>>r>>c;
        //行
        if(!hr.count(r)){
            hr[r]=++cnt_r;
            row[hr[r]].push_back({r,c,1});
        }
        else{
            row[hr[r]].push_back({r,c,1});
        }

        //列
        if(!hc.count(c)){
            hc[c]=++cnt_c;
            col[hc[c]].push_back({r,c,1});
        }
        else{
            col[hc[c]].push_back({r,c,1});
        }
    }
    
    for(int i=1;i<=cnt_r;i++){
        sort(row[i].begin(),row[i].end(),cmp_r);
    }
    for(int i=1;i<=cnt_c;i++){
        sort(col[i].begin(),col[i].end(),cmp_c);
    }
}

void get_seg(){
    //行
    for(int i=1;i<=cnt_r;i++){
        bool flag=false;
        node pre={0,0,0};
        for(int j=0;j<row[i].size();j++){
            auto d=row[i][j];
            if(d.tag==0){
                if(flag){
                    sg.push_back({pre,d});
                    pre=d;
                }
                else{
                    flag=true;
                    pre=d;
                }
            }
            else{
                flag=false;
            }
        }
    }

    //列
    for(int i=1;i<=cnt_c;i++){
        bool flag=false;
        node pre={0,0,0};
        for(int j=0;j<col[i].size();j++){
            auto d=col[i][j];
            if(d.tag==0){
                if(flag){
                    sg.push_back({pre,d});
                    pre=d;
                }
                else{
                    flag=true;
                    pre=d;
                }
            }
            else{
                flag=false;
            }
        }
    }
}

void clear(){
    for(int i=1;i<=cnt_r;i++) row[i].clear();
    for(int i=1;i<=cnt_c;i++) col[i].clear();
    for(int i=1;i<=1000;i++) st[i]=false;
    sg.clear();
    hr.clear();
    hc.clear();
    cnt_c=cnt_r=0;
    res.clear();
    ok=true;
}

void get_res(){
    unordered_set<PLL,pair_hash> ss;
    ll len=sg.size();

    idx=0;
    for(int i=0;i<len;i++) h[i]=-1,di[i]=0,st[i]=0;

    //存图
    for(int i=0;i<len;i++){
        for(int j=0;j<len;j++){
            if(i==j) continue;
            auto d=intersect(sg[i],sg[j]);
            if(d.r!=0||d.c!=0){
                ll x=i,y=j;
                if(x>y) swap(x,y);
                if(!ss.count({x,y})){
                    add(x,y),add(y,x);
                    ss.insert({x,y});
                }
            }
        }
    }

    //找出最优方案
    //priority_queue<op> q;
    vector<PLL> re;
    for(int i=0;i<len;i++){
        if(!st[i]){
            bool flag=false;
            for(int j=h[i];~j;j=ne[j]){
                int jj=e[j];
                if(!st[jj]){
                    st[i]=st[jj]=true;
                    re.push_back({i,jj});
                    flag=true;
                    break;
                }
            }
            if(!flag){
                re.push_back({i,-1});
                st[i]=true;
            }
        }
    }

    //求点
    for(int i=0;i<re.size();i++){
        auto dd=re[i];
        if(dd.second==-1){
            auto d=sg[dd.first];
            //为行
            if(d.l.r==d.r.r){
                if(d.l.c+1==d.r.c){
                    ok=false;
                }
                else{
                    res.push_back({d.l.r,d.l.c+1,0});
                }
            }
            //为列
            if(d.l.c==d.r.c){
                if(d.l.r+1==d.r.r){
                    ok=false;
                }
                else{
                    res.push_back({d.l.r+1,d.l.c,0});
                }
            }
        }
        else{
            auto d=intersect(sg[dd.first],sg[dd.second]);
            res.push_back({d.r,d.c,0});
        }
    }
}

int main(){
    cin>>t;
    while(t--){
        init();//读入数据并排序
        get_seg();//将数据处理成需要隔断的线段
        get_res();//得到答案
        if(ok){
            cout<<res.size()<<endl;
            for(auto d:res){
                cout<<d.r<<' '<<d.c<<endl;
            }
        }
        else{
            cout<<-1<<endl;
        }
        clear();
    }
    return 0;
}