#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int MAXN = 4'000'200;
int go[MAXN][26];
int len[MAXN];
int suff[MAXN];
int nodes_cnt = 0;

int trie_node() {
    fill(go[nodes_cnt], go[nodes_cnt] + 26, -1);
    suff[nodes_cnt] = -1;
    len[nodes_cnt] = 0;
    ++nodes_cnt;
    return nodes_cnt - 1;
}

vector<pair<int, int>> G[MAXN];
int bal[MAXN];
int id[MAXN];
vector<int> stackk;

void dfs(int v) {
    while (id[v] < G[v].size()) {
        int u = G[v][id[v]].first;
        int ind = G[v][id[v]].second;
        ++id[v];
        dfs(u);
        stackk.emplace_back(ind);
    }
}

void solve() {
    nodes_cnt = 0;
    trie_node();
    int n, m;
    cin >> n >> m;
    vector<string> A(n);
    auto push_line = [](const string& s) {
        int cur = 0;
        for (char c : s) {
            if (go[cur][c - 'a'] == -1) {
                go[cur][c - 'a'] = trie_node();
                len[go[cur][c - 'a']] = len[cur] + 1;
            }
            cur = go[cur][c - 'a'];
        }
        return cur;
    };
    for (int i = 0; i < n; ++i) {
        cin >> A[i];
        push_line(A[i]);
    }
    vector<string> B(n);
    for (int i = 0; i < n; ++i) {
        cin >> B[i];
        push_line(B[i]);
    }
    suff[0] = -1;
    deque<int> Q;
    Q.emplace_back(0);
    while (!Q.empty()) {
        int v = Q.front();
        Q.pop_front();
        for (int j = 0; j < 26; ++j) {
            if (go[v][j] == -1) {
                go[v][j] = v == 0 ? 0 : go[suff[v]][j];
            } else {
                Q.emplace_back(go[v][j]);
                suff[go[v][j]] = v == 0 ? 0 : go[suff[v]][j];
            }
        }
    }
    vector<vector<int>> A_prefs(n, vector<int>(m + 1, -1));
    vector<vector<int>> A_suffs(n, vector<int>(m + 1, -1));
    vector<vector<int>> B_prefs(n, vector<int>(m + 1, -1));
    vector<vector<int>> B_suffs(n, vector<int>(m + 1, -1));
    for (int i = 0; i < n; ++i) {
        int cur = 0;
        A_prefs[i][0] = 0;
        for (int j = 0; j < m; ++j) {
            cur = go[cur][A[i][j] - 'a'];
            A_prefs[i][j + 1] = cur;
        }
        while (cur != -1) {
            A_suffs[i][len[cur]] = cur;
            cur = suff[cur];
        }
    }
    for (int i = 0; i < n; ++i) {
        int cur = 0;
        B_prefs[i][0] = 0;
        for (int j = 0; j < m; ++j) {
            cur = go[cur][B[i][j] - 'a'];
            B_prefs[i][j + 1] = cur;
        }
        while (cur != -1) {
            B_suffs[i][len[cur]] = cur;
            cur = suff[cur];
        }
    }
    vector<int> all_lefts;
    vector<int> all_rights;
    for (int d = 0; d <= m; ++d) {
        all_lefts.clear();
        all_rights.clear();
        bool ok = true;
        for (int i = 0; i < n; ++i) {
            all_lefts.emplace_back(A_prefs[i][d]);
            if (B_suffs[i][d] == -1)
                ok = false;
            all_lefts.emplace_back(B_suffs[i][d]);
        }
        for (int i = 0; i < n; ++i) {
            if (A_suffs[i][m - d] == -1)
                ok = false;
            all_rights.emplace_back(A_suffs[i][m - d]);
            all_rights.emplace_back(B_prefs[i][m - d]);
        }
        if (!ok)
            continue;
        sort(all_lefts.begin(), all_lefts.end());
        all_lefts.resize(unique(all_lefts.begin(), all_lefts.end()) - all_lefts.begin());
        sort(all_rights.begin(), all_rights.end());
        all_rights.resize(unique(all_rights.begin(), all_rights.end()) - all_rights.begin());
        int n1 = all_lefts.size();
        int n2 = all_rights.size();
        fill(bal, bal + n1 + n2, 0);
        for (int i = 0; i < n; ++i) {
            int i1 = lower_bound(all_lefts.begin(), all_lefts.end(), A_prefs[i][d]) - all_lefts.begin();
            int i2 = lower_bound(all_rights.begin(), all_rights.end(), A_suffs[i][m - d]) - all_rights.begin();
            G[i1].emplace_back(n1 + i2, i);
            ++bal[i1];
            --bal[n1 + i2];
        }
        for (int i = 0; i < n; ++i) {
            int i1 = lower_bound(all_lefts.begin(), all_lefts.end(), B_suffs[i][d]) - all_lefts.begin();
            int i2 = lower_bound(all_rights.begin(), all_rights.end(), B_prefs[i][m - d]) - all_rights.begin();
            G[n1 + i2].emplace_back(i1, n + i);
            ++bal[n1 + i2];
            --bal[i1];
        }
        for (int i = 0; i < n1 + n2; ++i) {
            if (bal[i] != 0)
                ok = false;;
        }
        if (!ok) {
            for (int i = 0; i < n1 + n2; ++i) {
                G[i].clear();
            }
            continue;
        }
        fill(id, id + n1 + n2, 0);
        dfs(0);
        for (int i = 0; i < n1 + n2; ++i) {
            if (id[i] != G[i].size())
                ok = false;
        }
        if (!ok) {
            stackk.clear();
            for (int i = 0; i < n1 + n2; ++i) {
                G[i].clear();
            }
            continue;   
        }
        vector<int> order1;
        vector<int> order2;
        reverse(stackk.begin(), stackk.end());
        for (int i : stackk) {
            if (i < n)
                order1.emplace_back(i);
            else
                order2.emplace_back(i - n);
        }
        for (int x : order1)
            cout << x + 1 << ' ';
        cout << '\n';
        for (int x : order2)
            cout << x + 1 << ' ';
        cout << '\n';
        for (int i = 0; i < n1 + n2; ++i)
            G[i].clear();
        stackk.clear();
        return;
    }
    cout << -1 << '\n';
}

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

    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}