#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;


struct RollingHash {
    using ull = unsigned long long;
    RollingHash(const string& s = ""){
        build(s);
    }
    ull get(int l, int r){
        assert(0 <= l && l <= r && r <= n);
        return cal(inner_hash[r] + buf - mul(inner_hash[l], pow_base[r-l]));
    }
    static ull get_hash(const string& s){
        int len = s.size();
        set_hash();
        extend_pow_base(len);
        ull res = 0;
        rep(i,0,len) res = cal(mul(res, BASE) + s[i]);
        return res;
    }
    static ull concat(const ull& hash1, const ull& hash2, const int& len2){
        return cal(cal(mul(hash1, pow_base[len2])) + hash2);
    }
    private:
        static constexpr ull MASK30 = (1ULL << 30) - 1;
        static constexpr ull MASK31 = (1ULL << 31) - 1;
        static constexpr ull MASK61 = (1ULL << 61) - 1;
        static constexpr ull MOD = (1ULL << 61) - 1;
        static constexpr ull buf = MOD * 4;
        static ull BASE;
        static vector<ull> pow_base;
        static ull mul(ull a, ull b){
            ull au = a >> 31, ad = a & MASK31;
            ull bu = b >> 31, bd = b & MASK31;
            ull mid = ad * bu + au * bd;
            ull midu = mid >> 30, midd = mid & MASK30;
            return (au * bu * 2 + midu + (midd << 31) + ad * bd);
        }
        static ull cal(ull x){
            ull xu = x >> 61;
            ull xd = x & MASK61;
            ull res = xu + xd;
            if (res >= MOD) res -= MOD;
            return res;
        }
        static void set_hash(){
            if (BASE == 0) BASE = (1ULL << 31) + (random_device()() & MASK31);
        }
        static void extend_pow_base(int len){
            int nlen = pow_base.size();
            if (nlen > len) return;
            pow_base.resize(len + 1);
            rep(i, nlen, len + 1) pow_base[i] = cal(mul(pow_base[i-1], BASE));
        }
        string str;
        int n; 
        vector<ull> inner_hash;
        void build(const string& s){
            set_hash();
            str = s;
            n = s.size();
            extend_pow_base(n);
            inner_hash.resize(n+1);
            inner_hash[0] = 0;
            rep(i,0,n) inner_hash[i+1] = cal(mul(inner_hash[i], BASE) + s[i]);
        }
};
ull RollingHash::BASE = 0;
vector<ull> RollingHash::pow_base = vector<ull>(1, 1);
using roriha = RollingHash;



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];
    vector<roriha> hsa(n), hsb(n);
    rep(i,0,n){
        hsa[i] = roriha(a[i]);
        hsb[i] = roriha(b[i]);
    }
    rep(l,0,m){
        map<ull,int> ml, mr;
        int id = 0;
        auto getl = [&](ull s){
            if (ml.contains(s)) return ml[s];
            return ml[s] = id++;
        };
        auto getr = [&](ull s){
            if (mr.contains(s)) return mr[s];
            return mr[s] = id++;
        };
        vector<pii> ls(n), rs(n);
        rep(i,0,n){
            auto sl = hsa[i].get(0,l);
            auto sr = hsa[i].get(l,m);
            ls[i] = pii(getl(sl),getr(sr));
        }
        rep(i,0,n){
            auto sl = hsb[i].get(m-l,m);
            auto sr = hsb[i].get(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();
    }
}