using namespace std;
#include<iostream>
#include<fstream>
#include<vector>
#include<algorithm>
#define pb push_back
struct nod{
	int lg,f,c;};
struct dim{
int d[5];
};
vector<nod> G[1150];
dim a[510];
dim p[510];
int MAX;
int N,M,D,S;
int C[1150][1150];
int F[1150][1150];
int q[1150],ante[1150],viz[1150];
ofstream fout("pack.out");
bool BFS()
{ 
	int i;
	for(i=0;i<=D;i++)
	{
		viz[i]=0;
		q[i]=0;
		ante[i]=0;
	}
	
	q[++q[0]]=1;
	viz[S]=1;
	int front=1,u;
	vector<nod>::iterator it;
	while(front<=q[0])
	{
		u=q[front++];
		for(it=G[u].begin();it<G[u].end();it++)
		{
			if(!viz[it->lg] && C[u][it->lg]>F[u][it->lg] && it->c<=MAX)
			{
				viz[it->lg]=1;
				ante[it->lg]=u;
				q[++q[0]]=it->lg;
			}
		}
	}
	return viz[D];
}

bool dinic()
{
	int flow=0;
	int fmin,i,j;
	////// INITIALIZEAZA F[][] CU 0 ROURI
	for(i=0;i<=1100;i++)
	{
		for(j=0;j<=1100;j++)
		{
				F[i][j]=0;
		}
	}
	vector<nod>::iterator it;
	for(;BFS();)
	{
		for(it=G[D].begin();it<G[D].end();it++)
		{
			if(viz[it->lg])
			{
				fmin=C[it->lg][D]-F[it->lg][D];
				for(i=it->lg;i!=S;i=ante[i])
				{
					fmin=min(fmin,C[ante[i]][i]-F[ante[i]][i]);
				}
				F[it->lg][D]+=fmin;
				F[D][it->lg]-=fmin;
				for(i=it->lg;i!=S;i=ante[i])
				{
					F[ante[i]][i]+=fmin;
					F[i][ante[i]]-=fmin;
				}
				flow+=fmin;
			}
		}
		
	}
	fout<<MAX<<" "<<flow<<"\n";	
	return flow==N;
}

void solve()
{   int i,j; 
    int ok=0;
	for(i=0;i<=1000 && ok==0;i++)
	{
		MAX=i;
		if(dinic())
		{
			ok=1;
		}
		
		if(ok==1) 
		{	fout<<i<<"\n";
		for(i=1;i<=N;i++)
		{
			for(j=1;j<=M;j++)
			{
				if(F[1+i][1+N+j]==1)
					fout<<i<<" "<<j<<"\n";
			}
		}
		break;
		}
		
		
	}
	if(ok==0)
	{
		fout<<-1<<"\n";
	}
}


void cit()
{
	ifstream fin("pack.in");
	int i;
	fin>>N;
	for(i=1;i<=N;i++)
	{
		fin>>a[i].d[1]>>a[i].d[2]>>a[i].d[3];
		sort(a[i].d+1,a[i].d+4);
	}
	fin>>M;
	for(i=1;i<=M;i++)
	{
		fin>>p[i].d[1]>>p[i].d[2]>>p[i].d[3];
	}
	S=1;
	D=1+N+M+1;
	for(i=1;i<=N;i++)
	{
		C[1][1+i]=1;
		G[1].pb((nod){i+1,1,0});
		G[i+1].pb((nod){1,1,0});
	}
	int dummy;
	int j;
	for(i=1;i<=N;i++)
	{
		for(j=1;j<=M;j++)
		{
			if(p[j].d[1]>=a[i].d[1] &&
			   p[j].d[2]>=a[i].d[2] &&
			   p[j].d[3]>=a[i].d[3])
			   {
				 dummy=max(p[j].d[1]-a[i].d[1],
				       max(p[j].d[2]-a[i].d[2],
					       p[j].d[3]-a[i].d[3]));
                C[1+i][1+N+j]=1;
                G[1+i].pb((nod){1+N+j,1,dummy}); 
                G[1+N+j].pb((nod){1+i,1,dummy});				///negativ la flux maxim de cost minim
				
			   }  			   ////AM UITAT CA SE ROTESTE LOL!!!
		    while(next_permutation(a[i].d+1,a[i].d+4))
			{
			if(p[j].d[1]>=a[i].d[1] &&
			   p[j].d[2]>=a[i].d[2] &&
			   p[j].d[3]>=a[i].d[3])
			   {
				 dummy=max(p[j].d[1]-a[i].d[1],
				       max(p[j].d[2]-a[i].d[2],
					       p[j].d[3]-a[i].d[3]));
                C[1+i][1+N+j]=1;
                G[1+i].pb((nod){1+N+j,1,dummy}); 
				G[1+i].c=min(G[1+i].c,dummy);
                G[1+N+j].c=min(G[1+N+j].c,dummy);				///negativ la flux maxim de cost minim
				
			   }  	
			}
		}
	}
	for(i=1;i<=M;i++)
	{
		C[1+N+i][D]=1;
		G[1+N+1].pb((nod){D,1,0});
		G[D].pb((nod){1+N+1,1,0});
		
	}
	fin.close();
}

int main()
{
	cit();
	
	solve();
	fout.close();
	return 0;
}