#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back

const int mod1=1e9+7;
const int mod2=998244353;
const int mod3=1e9+9;
const int mods[3]={mod1, mod2, mod3};

int mod;
int add(int x,int y){x+=y;return x>=mod?x-mod:x;}
int sub(int x,int y){x-=y;return x<0?x+mod:x;}
int mul(int x,int y){return (ll)x*y%mod;}

int base=37;

const int N=2000050;
char s[N];
int hsh[N];
int po[N];

int Get(int l,int r){
	//printf("Get (%i %i): ",l,r);
	//for(int i=l;i<=r;i++)printf("%c",s[i]);
	//printf("\n");
	return sub(hsh[r],mul(hsh[l-1],po[r-l+1]));
}

vector<vector<pair<int,int>>> E;
vector<int> in,out;
void AddEdge(int u,int v,int id){
	//printf("(%i) %i -> %i\n",id,u,v);
	E[u].pb({v,id});
	in[v]++;
	out[u]++;
}

vector<int> cycle;
vector<bool> was;
vector<int> ptr;

void Euler(int u){
	while(true){
		while(ptr[u]<E[u].size() && was[E[u][ptr[u]].second])ptr[u]++;
		if(ptr[u]==E[u].size()){
			break;
		}
		int e=E[u][ptr[u]].second;
		was[e]=true;
		Euler(E[u][ptr[u]].first);
		cycle.pb(e);
	}
}

int main(){
	mt19937 rng(time(0));
	int t;
	scanf("%i",&t);
	while(t--){
		int n,m;
		scanf("%i %i",&n,&m);
		for(int i=1;i<=n;i++){
			scanf("%s",s+(i-1)*m+1);
		}
		for(int i=1;i<=n;i++){
			scanf("%s",s+(n+i-1)*m+1);
		}

		vector<vector<vector<int>>> LHA(3,vector<vector<int>>(n+1,vector<int>(m,0)));
		auto RHA=LHA;
		auto LHB=LHA;
		auto RHB=LHA;

		for(int md=0;md<3;md++){
			mod=mods[md];
			base=rng()%(mod/2)+mod/2;
			int sz=n*2*m;
			po[0]=1;
			for(int i=1;i<=sz;i++){
				hsh[i]=add(mul(hsh[i-1],base),s[i]-'a'+1);
				po[i]=mul(po[i-1],base);
			}
			for(int sh=0;sh<m;sh++){
				for(int i=1;i<=n;i++){
					LHA[md][i][sh]=Get((i-1)*m+1,(i-1)*m+1+m-sh-1);
					RHA[md][i][sh]=Get((i-1)*m+1+m-sh,i*m);

					LHB[md][i][sh]=Get((n+i-1)*m+1,(n+i-1)*m+1+sh-1);
					RHB[md][i][sh]=Get((n+i-1)*m+1+sh,(n+i)*m);
				}
			}
		}

		bool ok=false;
		vector<int> ans;

		for(int sh=0;sh<m;sh++){
			//printf("Shift %i\n",sh);
			map<array<int,4>,int> node;
			int cnt=0;
			for(int i=1;i<=n;i++){
				if(!node[{LHA[0][i][sh], LHA[1][i][sh], LHA[2][i][sh], 1}]){
					node[{LHA[0][i][sh], LHA[1][i][sh], LHA[2][i][sh], 1}]=++cnt;
				}
				if(!node[{LHB[0][i][sh], LHB[1][i][sh], LHB[2][i][sh], 2}]){
					node[{LHB[0][i][sh], LHB[1][i][sh], LHB[2][i][sh], 2}]=++cnt;
				}
				if(!node[{RHA[0][i][sh], RHA[1][i][sh], RHA[2][i][sh], 2}]){
					node[{RHA[0][i][sh], RHA[1][i][sh], RHA[2][i][sh], 2}]=++cnt;
				}
				if(!node[{RHB[0][i][sh], RHB[1][i][sh], RHB[2][i][sh], 1}]){
					node[{RHB[0][i][sh], RHB[1][i][sh], RHB[2][i][sh], 1}]=++cnt;
				}
			}
			E.clear();
			E.resize(cnt+1);
			in.clear();
			in.resize(cnt+1);
			out.clear();
			out.resize(cnt+1);
			for(int i=1;i<=n;i++){
				int la=node[{LHA[0][i][sh], LHA[1][i][sh], LHA[2][i][sh], 1}];
				int ra=node[{RHA[0][i][sh], RHA[1][i][sh], RHA[2][i][sh], 2}];
				AddEdge(la,ra,i);
				int lb=node[{LHB[0][i][sh], LHB[1][i][sh], LHB[2][i][sh], 2}];
				int rb=node[{RHB[0][i][sh], RHB[1][i][sh], RHB[2][i][sh], 1}];
				AddEdge(lb,rb,n+i);
			}
			bool good=true;
			for(int i=1;i<=cnt;i++){
				if(in[i]!=out[i]){
					good=false;
					break;
				}
			}
			if(good){
				was.clear();
				was.assign(2*n+1,false);
				ptr.clear();
				ptr.assign(cnt+1,0);
				cycle.clear();
				Euler(1);
				//for(int i:cycle)printf("%i ",i);
				//printf("\n");
				if(cycle.size()==2*n){
					ok=true;
					ans=cycle;
					break;
				}
			}
		}

		if(ok){
			vector<int> a,b;
			reverse(ans.begin(),ans.end());
			for(int i:ans){
				if(i>n)b.pb(i-n);
				else a.pb(i);
			}
			for(int i:a)printf("%i ",i);
			printf("\n");
			for(int i:b)printf("%i ",i);
			printf("\n");
		}else{
			printf("-1\n");
		}
	}
	return 0;
}