#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define X first
#define Y second
#define ALL(v) v.begin(), v.end()
#define pb push_back
#define SZ(a) ((int)a.size())

const int MAXL = 1000000;
const int C = 2;

const int MOD[C] = {998244853, int(1e9 + 9)};
const int P[C] = {31, 37};
int base[C][MAXL + 5];

void add(int &x, int val, int t) {
    x += val;
    if (x >= MOD[t]) x -= MOD[t];
}

typedef array<int, 2> Hash;

vector<pii> G[4000005];
vector<int> stk;
int pt[4000005], in[4000005], out[4000005];

void init(int n) {
    for (int i = 0; i < n; ++i) G[i].clear();
    stk.clear();
    fill_n(pt, n, 0), fill_n(in, n, 0), fill_n(out, n, 0);
}

void add_edge(int u, int v, int i) {
    G[u].pb(pii(v, i));
    ++in[v], ++out[u];
    //cerr << "add_edge " << u << " " << v << " " << i << "\n";
}

void dfs(int u) {
    for (int &i = pt[u]; i < SZ(G[u]);) {
        auto [e, idx] = G[u][i++];
        dfs(e);
        stk.pb(idx);
    }
}

void solve() {
    int n, m;
    cin >> n >> m;
    vector<vector<Hash>> prxA(n), prxB(n), sfxA(n), sfxB(n);
    vector<string> A(n), B(n);
    for (auto &s : A)
        cin >> s;
    for (auto &s : B)
        cin >> s;

    {
        vector<int> idxA(n), idxB(n); 
        iota(ALL(idxA), 0), iota(ALL(idxB), 0);
        sort(ALL(idxA), [&](int a, int b) {
            return A[a] < A[b]; 
        });
        sort(ALL(idxB), [&](int a, int b) {
            return B[a] < B[b]; 
        });
        int flag = 1;
        for (int i = 0; i < n && flag; ++i)
            if (A[idxA[i]] != B[idxB[i]])
                flag = 0;
        if (flag) {
            for (int i = 0; i < n; ++i)
                cout << idxA[i] + 1 << " \n"[i + 1 == n];
            for (int i = 0; i < n; ++i)
                cout << idxB[i] + 1 << " \n"[i + 1 == n];
            return;
        }
    }

    auto build = [&](auto &S, auto &prx, auto &sfx) {
        for (int i = 0; i < n; ++i) {
            Hash cur = Hash();
            prx[i].pb(cur);
            for (int j = 0; j < m; ++j) {
                for (int k = 0; k < C; ++k)
                    add(cur[k], (ll)(S[i][j] - 'a') * base[k][j] % MOD[k], k);
                prx[i].pb(cur);
            }
            cur = Hash();
            sfx[i].pb(cur);
            for (int j = m - 1; j >= 0; --j) {
                for (int k = 0; k < C; ++k) {
                    cur[k] = (ll)cur[k] * P[k] % MOD[k];
                    add(cur[k], int(S[i][j] - 'a'), k);
                }
                sfx[i].pb(cur);
            }
        }
    };

    build(A, prxA, sfxA);
    build(B, prxB, sfxB);

    for (int i = 1; i < m; ++i) {
        vector<Hash> white, black;
        for (int j = 0; j < n; ++j) {
            white.pb(prxA[j][i]);
            white.pb(sfxB[j][i]);
            black.pb(sfxA[j][m - i]);
            black.pb(prxB[j][m - i]);
        }
        sort(ALL(white)), white.resize(unique(ALL(white)) - white.begin());
        sort(ALL(black)), black.resize(unique(ALL(black)) - black.begin());
        init(SZ(white) + SZ(black));
        /*cerr << "shifted " << i << ", SZ(white) = " << SZ(white) << ", SZ(black) = " << SZ(black) << "\n";
        for (int j = 0; j < n; ++j)
            cerr << "(" << prxA[j][i][0] << ", " << sfxA[j][m - i][0] << ") ";
        cerr << endl;
        for (int j = 0; j < n; ++j)
            cerr << "(" << prxB[j][m - i][0] << ", " << sfxB[j][i][0] << ") ";
        cerr << endl;*/
        for (int j = 0; j < n; ++j) {
            int widx, bidx;

            // A: w->b
            widx = lower_bound(ALL(white), prxA[j][i]) - white.begin();
            bidx = lower_bound(ALL(black), sfxA[j][m - i]) - black.begin();
            bidx += SZ(white);
            add_edge(widx, bidx, j);

            // B: b->w
            widx = lower_bound(ALL(white), sfxB[j][i]) - white.begin();
            bidx = lower_bound(ALL(black), prxB[j][m - i]) - black.begin();
            bidx += SZ(white);
            add_edge(bidx, widx, j + n);
        }

        int flag = 1;
        for (int j = 0; j < SZ(white) + SZ(black); ++j)
            if (in[j] != out[j])
                flag = 0;

        if (!flag) continue;

        vector<int> ansA, ansB;
        dfs(0);
        reverse(ALL(stk));
        for (int idx : stk)
            if (idx >= n) ansB.pb(idx - n);
            else ansA.pb(idx);
        if (SZ(ansA) != n || SZ(ansB) != n)
            continue;
        assert(SZ(ansA) == n);
        assert(SZ(ansB) == n);
        for (int idx = 0; idx < n; ++idx)
            cout << ansA[idx] + 1 << " \n"[idx + 1 == n];
        for (int idx = 0; idx < n; ++idx)
            cout << ansB[idx] + 1 << " \n"[idx + 1 == n];

        return;
    }
    cout << "-1\n";
}

int main() {
    ios::sync_with_stdio(0), cin.tie(0);
    for (int i = 0; i < 2; ++i) {
        base[i][0] = 1;
        for (int j = 1; j <= MAXL; ++j)
            base[i][j] = (ll)base[i][j - 1] * P[i] % MOD[i];
    }
    int t;
    cin >> t;
    while (t--) {
        solve();
    }
}