#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define int ll

const int N=1e6+100;
const int MOD=int(1e18)+3;
const int BASE=31;

int mul(int x,int y)
{
    return (__int128)x*y%MOD;
}

int pw[N];
vector<int> pref_a[N],suff_a[N],pref_b[N],suff_b[N];

void read(vector<int>&pref,vector<int>&suff)
{
    string s;
    cin>>s;
    for(char&c:s)
        c-='a'-1;
    int m=s.size();
    pref.resize(m+1);
    pref[0]=0;
    for(int i=1;i<=m;i++)
        pref[i]=(mul(pref[i-1],BASE)+s[i-1])%MOD;
    suff.resize(m+1);
    suff[m]=0;
    for(int i=m-1;i>=0;i--)
        suff[i]=(suff[i+1]+mul(s[i],pw[m-1-i]))%MOD;
}

unordered_map<int,vector<pair<int,int>>> g;
unordered_map<int,int> h;
vector<int> ans;
unordered_map<int,vector<pair<int,int>>::iterator> its;
unordered_set<int> eu;

vector<int> euler_walk(int nedges, int src) {
    int c = 0;
    for(auto&[n,n_outs]:g)
        c += abs(int(h[n] - n_outs.size()));
    if (c > 2) return {};
    its.clear();
    for(auto&[n,n_outs]:g)
        its[n]=n_outs.begin();
    eu.clear();
    vector<int> ret, s = {src};
    while(!s.empty()) {
        int x = s.back();
        auto& it = its[x], end = g[x].end();
        while(it != end && eu.count(it->second)) ++it;
        if(it == end) { s.pop_back(); if(!s.empty()) ret.push_back(s.back()), s.pop_back(); }
        else { s.push_back(it->second); s.push_back(it->first); eu.insert(it->second); }
    }
    if(ret.size() != nedges)
        ret.clear(); // No Eulerian cycles/paths.
    // else, non-cycle if ret.front() != ret.back()
    reverse(ret.begin(),ret.end());
    return ret;
}

signed main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    pw[0]=1;
    for(int i=1;i<N;i++)
        pw[i]=mul(pw[i-1],BASE);

    int t;
    cin>>t;
    while(t--)
    {
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;i++)
            read(pref_a[i],suff_a[i]);
        for(int i=1;i<=n;i++)
            read(pref_b[i],suff_b[i]);
        bool found=false;
        for(int d=0;d<m;d++)
        {
            g.clear();
            h.clear();
            auto add=[&](int u,int v,int c)
            {
                g[u].emplace_back(v,c);
                h[v]++;
                g[v];
                h[u];
            };
            for(int i=1;i<=n;i++)
                add(pref_a[i][d],~suff_a[i][d],i);
            for(int i=1;i<=n;i++)
                add(~pref_b[i][m-d],suff_b[i][m-d],-i);
            bool ok=true;
            for(const auto&[v,gv]:g)
                if(gv.size()!=h[v])
                {
                    ok = false;
                    break;
                }
            if(!ok)
                continue;
            auto cycle= euler_walk(2*n,g.begin()->first);
            if(cycle.empty())
                continue;
            found=true;
            for(int x:cycle)
                if(x>0)
                    cout<<x<<" ";
            cout<<"\n";
            for(int x:cycle)
                if(x<0)
                    cout<<-x<<" ";
            cout<<"\n";
            break;
        }
        if(!found)
            cout<<-1<<"\n";
    }
}