#include <algorithm>
#include <iostream>
#include <vector>
#include <unordered_map>

using ll = long long;
using ull = unsigned long long;
using u128 = __uint128_t;

constexpr ull mod = (1LL << 61) - 1;
constexpr ull base = 33554432;
std::vector<ull> base_pow, base_inv_pow;

inline ull add(ull a, ull b) {
    a += b;
    if (a >= mod) a -= mod;
    return a;
}

inline ull mul(ull a, ull b) {
    u128 t = (u128)a * b;
    ull na = t >> 61;
    ull nb = t & mod;
    return add(na, nb);
}

inline ull pow(ull a, ull b) {
    ull res = 1;
    while (b) {
        if (b & 1) res = mul(res, a);
        a = mul(a, a);
        b >>= 1;
    }
    return res;
}

void init_base_pow() {
    int max_len = 1e6 + 10;
    base_pow.resize(max_len);
    base_inv_pow.resize(max_len);
    base_pow[0] = 1;
    base_inv_pow[0] = 1;

    ull base_inv = pow(base, mod - 2);
    for (int i = 1; i < max_len; i++) {
        base_pow[i] = base_pow[i - 1] * base % mod;
        base_inv_pow[i] = base_inv_pow[i - 1] * base_inv % mod;
    }
}

struct Hash {
    int n;
    std::vector<ull> h;

    Hash(std::string &s) {
        n = s.size();
        h.resize(n + 1);
        for (int i = 0; i < n; i++) {
            h[i + 1] = add(mul(h[i], base), s[i]);
        }
    }

    ull get(int l, int r) {
        return add(h[r], mod - mul(h[l], base_pow[r - l]));
    }
};

// struct UF {
//     std::unordered_map<ull, std::tuple<ull, int, int>> uf; // parent, size, count

//     UF() {}

//     void add(ull x) {
//         if (!uf.contains(x)) uf[x] = {x, 1, 0};
//     }

//     ull find(ull x) {
//         if (std::get<0>(uf[x]) == x) return x;
//         return std::get<0>(uf[x]) = find(std::get<0>(uf[x]));
//     }

//     void unite(ull x, ull y) {
//         add(x);
//         add(y);
//         std::get<2>(uf[x])++;
//         std::get<2>(uf[y])++;

//         x = find(x);
//         y = find(y);
//         if (x == y) return;
//         if (std::get<1>(uf[x]) < std::get<1>(uf[y])) std::swap(x, y);
//         std::get<0>(uf[y]) = x;
//         std::get<1>(uf[x]) += std::get<1>(uf[y]);
//     }
// };

void solve() {
    int n, m;
    std::cin >> n >> m;

    std::vector<Hash> hs, ht;
    for (int i = 0; i < n; i++) {
        std::string s;
        std::cin >> s;
        hs.emplace_back(s);
    }
    for (int i = 0; i < m; i++) {
        std::string t;
        std::cin >> t;
        ht.emplace_back(t);
    }

    for (int i = 0; i < m; i++) {
        std::unordered_map<ull, std::vector<std::pair<ull, int>>> graph;
        std::unordered_map<ull, int> in_count;
        int j = 0;
        for (Hash &h: hs) {
            ull a = h.get(0, i) * 2;
            ull b = h.get(i, m) * 2 + 1;
            // std::cout << "hashs " << "i " << i << " " << a << " " << b << "\n";
            graph[a].emplace_back(b, j++);
            in_count[b]++;
        }
        for (Hash &h: ht) {
            ull a = h.get(0, m - i) * 2 + 1;
            ull b = h.get(m - i, m) * 2;
            // std::cout << "hasht " << "i " << i << " " << a << " " << b << "\n";
            graph[a].emplace_back(b, j++);
            in_count[b]++;
        }

        bool ok = true;
        for (auto &[x, cnt]: in_count) {
            if (graph[x].size() != cnt) {
                // std::cout << "test_ " << i << " " << x << " " << graph[x].size() << " " << cnt << "\n";
                ok = false;
                break;
            }
        }
        if (!ok) {
            // std::cout << "test " << i << "\n";
            continue;
        }

        ull from = graph.begin()->first;

        std::vector<int> path, back_path;

        // construct euler path
        auto dfs = [&](auto &&self, ull x) -> void {
            if (graph[x].empty()) {
                if (x != from) {
                    path.insert(path.end(), back_path.begin(), back_path.end());
                    back_path.clear();
                }
            } else {
                auto [y, id] = graph[x].back();
                graph[x].pop_back();
                back_path.push_back(id);
                self(self, y);
            }
        };
        dfs(dfs, from);
        path.insert(path.end(), back_path.begin(), back_path.end());

        if (path.size() != 2 * n) {
            // std::cout << "test2 " << i << "\n";
            continue;
        }

        std::vector<int> a, b;
        for (int e: path) {
            if (e < n) {
                a.push_back(e);
            } else {
                b.push_back(e - n);
            }
        }

        for (int j: a) {
            std::cout << j + 1 << " ";
        }
        std::cout << "\n";
        for (int j: b) {
            std::cout << j + 1 << " ";
        }
        std::cout << "\n";
        return;
    }

    std::cout << "-1\n";
}


int main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    init_base_pow();

    int t;
    std::cin >> t;
    while (t--) solve();
}