#include <bits/stdc++.h>


using namespace std;


using ll = long long;
using lll = __int128_t;

#define rep(i, n) for(int i = 0; i < (n); i += 1)
#define rng(i, start, end, step) for(int i = start; i < end; i += step)
#define len(a) ((int)(a).size())


mt19937 rnd(234);

const ll mod = 1e18 + 3;
const ll p = 123141231123124;


int n, m;
vector<string> a, b;
vector<vector<ll>> pa, pb, sa, sb;

struct edge {
    int to;
    int i;
};


int32_t main() {
    if (1) {
        ios::sync_with_stdio(0);
        cin.tie(0);
        cout.tie(0);
    }
    int tests;
    cin >> tests;
    rep(test, tests) {
        cin >> n >> m;
        a.resize(n);
        b.resize(n);
        rep(i, n) cin >> a[i];
        rep(i, n) cin >> b[i];
        pa.assign(n, vector<ll>(m + 1));
        pb.assign(n, vector<ll>(m + 1));
        sa.assign(n, vector<ll>(m + 1));
        sb.assign(n, vector<ll>(m + 1));
        rep(i, n) {
            pa[i][0] = pb[i][0] = 0;
            rep(j, m) {
                pa[i][j + 1] = (lll(pa[i][j]) * p + a[i][j] - 'a' + 1) % mod;
                pb[i][j + 1] = (lll(pb[i][j]) * p + b[i][j] - 'a' + 1) % mod;
            }
            sa[i][0] = sb[i][0] = 0;
            lll pw = 1;
            rep(j, m) {
                sa[i][j + 1] = (sa[i][j] + (a[i][m - j - 1] - 'a' + 1) * pw) % mod;
                sb[i][j + 1] = (sb[i][j] + (b[i][m - j - 1] - 'a' + 1) * pw) % mod;
                pw = pw * p % mod;
            }
        }
        vector<int> p, q;
        for (int len = 1; len <= m; len += 1) {
            vector<ll> left, right;
            rep(i, n) {
                left.push_back(pa[i][len]);
                right.push_back(pb[i][m - len]);
            }
            sort(left.begin(), left.end());
            sort(right.begin(), right.end());
            left.resize(unique(left.begin(), left.end()) - left.begin());
            right.resize(unique(right.begin(), right.end()) - right.begin());
            bool ok = true;
            vector<vector<edge>> g(len(left) + len(right));
            rep(i, n) {
                if (!binary_search(right.begin(), right.end(), sa[i][m - len])) {
                    ok = false;
                    break;
                }
                if (!binary_search(left.begin(), left.end(), sb[i][len])) {
                    ok = false;
                    break;
                }
            }
            if (!ok) {
                continue;
            }
            vector<int> d(len(left) + len(right));
            rep(i, n) {
                int u = lower_bound(left.begin(), left.end(), pa[i][len]) - left.begin();
                int v = lower_bound(right.begin(), right.end(), sa[i][m - len]) - right.begin();
                v += len(left);
                g[u].push_back(edge{ v, i });
                d[u] += 1; d[v] -= 1;

                u = lower_bound(right.begin(), right.end(), pb[i][m - len]) - right.begin();
                v = lower_bound(left.begin(), left.end(), sb[i][len]) - left.begin();
                u += len(left);
                g[u].push_back(edge{ v, n + i });
                d[u] += 1; d[v] -= 1;
            }
            if (!all_of(d.begin(), d.end(), [&](int x) {return x == 0;})) continue;
            vector<int> pntr(2 * n, 0);
            int start = 0;
            while (start < 2 * n and g[start].empty()) ++start;
            assert(start < 2 * n);
            function<void(int)> dfs;
            vector<int> way;
            dfs = [&](int v) {
                for (int& i = pntr[v]; i < len(g[v]);) {
                    auto [to, e] = g[v][i];
                    i += 1;
                    dfs(to);
                    way.push_back(e);
                }
                };
            dfs(start);
            if (len(way) != 2 * n) continue;
            reverse(way.begin(), way.end());
            for (auto x : way) {
                if (x < n) {
                    p.push_back(x);
                } else {
                    q.push_back(x - n);
                }
            }
            assert(len(p) == n and len(q) == n);
            break;
        }
        if (p.empty() or q.empty()) {
            cout << -1 << "\n";
        } else {
            for (auto x : p) cout << x + 1 << " "; cout << "\n";
            for (auto x : q) cout << x + 1 << " "; cout << "\n";
        }
    }
    return 0;
}