#include <bits/stdc++.h>
#define ff first
#define ss second
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

typedef unsigned long long ull;
typedef pair<ull, ull> puu;

int n, m;
vector<string> S[2];

mt19937 rnd(1557);
ull rng(ull l, ull r) {
	return uniform_int_distribution<ull>(l, r)(rnd);
}

ull ps[26];
ull B;

// euler circuit

const int SZ = 1010101;
vector<pii> g[SZ];

int sp[SZ];
vector<int> ST;
void dfs(int f, int v) {
	while (sp[v] < g[v].size()) {
		auto [e, x] = g[v][sp[v]++];
		dfs(e, x);
	}
	if (f != -1) ST.push_back(f);
}
int main() {
	cin.tie(0); ios_base::sync_with_stdio(0);
	
	int T;
	cin >> T;

	for (int i = 0; i < 26; i++) ps[i] = rng(0, -1);
	B = rng(0, -1);

	while (T--) {
		cin >> n >> m;
		for (int t = 0; t < 2; t++) {
			for (int i = 0; i < n; i++) {
				string K; cin >> K;
				S[t].push_back(K);
			}
		}

		{ // no offset
			int ord[2][n];
			for (int t = 0; t < 2; t++) {
				for (int i = 0; i < n; i++) {
					ord[t][i] = i;
				}
				sort(ord[t], ord[t] + n, [&](int i, int j) {
					return S[t][i] < S[t][j];
				});
			}

			bool f = true;
			for (int i = 0; i < n; i++) {
				if (S[0][ord[0][i]] != S[1][ord[1][i]]) {
					f = false;
				}
			}

			if (f) {
				for (int i = 0; i < n; i++) cout << ++ord[0][i] << ' ';
				cout << '\n';
				
				for (int i = 0; i < n; i++) cout << ++ord[1][i] << ' ';
				cout << '\n';

				S[0].clear(); S[1].clear();
				continue;
			}
		}
		
		vector<vector<puu>> V[2];

		for (int t = 0; t < 2; t++) {
			V[t].resize(n);
			for (int i = 0; i < n; i++) {
				string &K = S[t][i];

				vector<ull> p(m), s(m);

				p[0] = ps[K[0] - 'a'];
				for (int j = 1; j < m; j++) {
					p[j] = B * p[j - 1] + ps[K[j] - 'a'];
				}

				s[m - 1] = ps[K[m - 1] - 'a'];
				ull ms = 1;
				for (int j = m - 1; j > 0; j--) {
					ms *= B;
					s[j - 1] = ms * ps[K[j - 1] - 'a'] + s[j];
				}

				for (int j = 0; j < m; j++) {
					V[t][i].push_back({ p[j], s[j] });
				}

				// for (auto [x, y] : V[t][i]) {
				// 	cout << "(" << x << ", " << y << ") ";
				// }
				// cout << '\n';
			}
			// cout << '\n';
		}

		auto f = [&](vector<ull> &V, ull x) {
			int p = lower_bound(V.begin(), V.end(), x) - V.begin();

			if (p == V.size() || V[p] != x) {
				return -1;
			}
			else return p;
		};

		bool found = false;
		for (int x = 1; x < m; x++) {
			vector<ull> L, R;

			for (int i = 0; i < n; i++) {
				L.push_back(V[0][i][x - 1].first);
				R.push_back(V[0][i][x].second);
			}

			sort(L.begin(), L.end());
			L.erase(unique(L.begin(), L.end()), L.end());

			sort(R.begin(), R.end());
			R.erase(unique(R.begin(), R.end()), R.end());

			int sz = L.size();
			int tz = R.size();
			
			int deg[sz + tz] = {};

			// cout << "Case " << x << "?\n";

			for (int i = 0; i < n; i++) {
				int u = f(L, V[0][i][x - 1].first);
				int v = f(R, V[0][i][x].second);

				g[u].push_back({i, v + sz});
				deg[u]++;
				deg[v + sz]--;
				
				// cout << V[0][i][x - 1].first << ' ' << V[0][i][x].second << '\n';
				// cout << "A " << u << " -> " << v + sz << '\n';
			}

			bool flag = true;
			for (int i = 0; i < n; i++) {
				int u = f(R, V[1][i][m - x - 1].first);
				int v = f(L, V[1][i][m - x].second);
				
				// cout << V[1][i][m - x - 1].first << ' ' << V[1][i][m - x].second << '\n';

				if (u == -1 || v == -1) {
					flag = false;
					break;
				}

				g[u + sz].push_back({n + i, v});
				deg[u + sz]++;
				deg[v]--;

				// cout << "B " << u + sz << " -> " << v << '\n';
			}

			if (flag) {
				bool yes = true;
				for (int v = 0; v < sz + tz; v++) {
					if (deg[v] != 0) {
						yes = false;
						break;
					}
				}
				if (yes) {
					dfs(-1, 0);
					if (ST.size() == 2 * n) {
						found = true;

						vector<int> A, B;
						while (!ST.empty()) {
							int e = ST.back();
							ST.pop_back();

							if (e < n) A.push_back(e);
							else B.push_back(e - n);
						}

						for (int x : A) cout << ++x << ' ';
						cout << '\n';

						for (int x : B) cout << ++x << ' ';
						cout << '\n';
					}
					ST.clear();
					for (int i = 0; i < sz + tz; i++) {
						sp[i] = 0;
					}
				}
			}
			for (int i = 0; i < sz + tz; i++) {
				g[i].clear();
			}

			if (found) break;
		}
		if (!found) cout << "-1\n";

		S[0].clear(); S[1].clear();
	}
}