#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ull = unsigned long long;
using ld = long double;

template<class T>
bool chmin(T &a, T b) {
    if(a <= b) return false;
    a = b;
    return true;
}

template<class T>
bool chmax(T &a, T b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;
using pii = pair<int,int>;

template<typename T>
ostream &operator<<(ostream &os, vector<T> &a){
    const char* delim = "";
    for (auto &x : a){
        os << exchange(delim," ") << x;
    }
    return os;
}

vector<int> circle(vector<pii> es, int n){
    int m = es.size();
    vector<vector<pii>> g(n);
    for (int i = 0; auto [u, v] : es) g[u].emplace_back(v,i++);
    {
        vector<int> ideg(n,0), odeg(n,0);
        rep(i,0,m){
            auto [u, v] = es[i];
            ideg[v]++, odeg[u]++;
        }
        rep(i,0,n){
            if (ideg[i] != odeg[i]){
                return {};
            }
        }
    }
    vector<int> to(m,-1);
    auto dfs = [&](auto sfs, int v) -> pii {
        if (g[v].empty()) return pii(-1,-1);
        vector<int> edges;
        int cur = v;
        while (true){
            auto [nxt, eid] = g[cur].back(); g[cur].pop_back();
            edges.emplace_back(eid);
            if (nxt == v) break;
            cur = nxt; 
        }
        int sz = edges.size();
        rep(i,0,sz-1){
            to[edges[i]] = edges[i+1];
            // lv -- e[i] --> mv -- e[i+1] --> rv
            auto [le, re] = sfs(sfs,es[edges[i]].second);
            if (le != -1){
                to[edges[i]] = le;
                to[re] = edges[i+1];
            }
        }
        auto [le, re] = sfs(sfs,v);
        if (le != -1){
            to[edges.back()] = le;
            return pii(edges.front(),re);
        }
        return pii(edges.front(),edges.back());
    };
    auto [le, re] = dfs(dfs,0);
    vector<int> ans = {le};
    while (le != re){
        le = to[le];
        ans.emplace_back(le);
    }
    if ((int)ans.size() == m){
        return ans;
    }
    return {};
}

void jikken(){
    int n, m; cin >> n >> m;
    vector<pii> es(m);
    rep(i,0,m){
        int u, v; cin >> u >> v;
        es[i] = pii(u,v);
    }
    //shuffle(all(es),mt19937(0));
    auto ans = circle(es,n);
    cout << ans << endl;
    exit(0);
}

void solve(){ //jikken();
    int n, m; cin >> n >> m;
    vector<string> a(n), b(n);
    rep(i,0,n) cin >> a[i];
    rep(i,0,n) cin >> b[i];
    rep(l,0,m){
        map<string,int> ml, mr;
        int id = 0;
        auto getl = [&](string s){
            if (ml.contains(s)) return ml[s];
            return ml[s] = id++;
        };
        auto getr = [&](string s){
            if (mr.contains(s)) return mr[s];
            return mr[s] = id++;
        };
        vector<pii> ls(n), rs(n);
        rep(i,0,n){
            auto sl = a[i].substr(0,l);
            auto sr = a[i].substr(l);
            ls[i] = pii(getl(sl),getr(sr));
        }
        rep(i,0,n){
            auto sl = b[i].substr(m-l);
            auto sr = b[i].substr(0,m-l);
            rs[i] = pii(getr(sr),getl(sl));
        }
        ls.insert(ls.end(),all(rs));
        auto ans = circle(ls,id);
        if (ans.empty()) continue;
        vector<int> ansa(n), ansb(n);
        int ida = 0, idb = 0;
        for (auto i : ans){
            if (i < n){
                ansa[ida++] = i+1;
            }
            else {
                ansb[idb++] = i-n+1;
            }
        }
        rep(i,0,n){
            cout << ansa << endl;
            cout << ansb << endl;
            return ;
        }
    }
    cout << -1 << endl;
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int t; cin >> t;
    while (t--){
        solve();
    }
}