#include <bits/extc++.h>

namespace hash_map_impl {

struct custom_hash {
	using T = uint64_t;

	T operator ()(T x) const {
		static const T c = uint64_t(4e18*std::acos(0))|71;
		static const T z = std::chrono::steady_clock::now().time_since_epoch().count();
		return __builtin_bswap64((x ^ z) * c);
	}
};

template <typename K, typename V, typename H = custom_hash>
using hash_map = __gnu_pbds::gp_hash_table<K, V, H>;

template <typename K, typename H = custom_hash>
using hash_set = hash_map<K, __gnu_pbds::null_type, H>;

} // namespace hash_map_impl

namespace string_hasher {

struct hashnum {
	using ull = unsigned long long;
	static constexpr ull m = (ull(1) << 61) - 1;
	static constexpr ull m8 = m * 8;

	ull v;
	hashnum() : v(0) {}
	hashnum(ull a) : v(a % m * 8) {}
	ull get() const {
		return v == m8 ? 0 : v;
	}

	hashnum& operator += (const hashnum& o) {
		if (__builtin_uaddll_overflow(v, o.v, &v)) v -= m8;
		return *this;
	}
	hashnum& operator -= (const hashnum& o) {
		if (__builtin_usubll_overflow(v, o.v, &v)) v += m8;
		return *this;
	}
	hashnum& operator *= (const hashnum& o) {
		__uint128_t t = __uint128_t(v) * o.v;
		ull x = ull(t >> 67 << 3);
		ull y = ull(t << 61 >> 64);
		if (__builtin_uaddll_overflow(x, y, &v)) v -= m8;
		return *this;
	}

	friend bool operator == (const hashnum& a, const hashnum& b) { return a.get() == b.get(); }

	friend hashnum operator + (const hashnum& a, const hashnum& b) { return hashnum(a) += b; }
	friend hashnum operator - (const hashnum& a, const hashnum& b) { return hashnum(a) -= b; }
	friend hashnum operator * (const hashnum& a, const hashnum& b) { return hashnum(a) *= b; }
};

using string_hasher = hashnum;

string_hasher rand_base() {
	static std::mt19937_64 mt(std::chrono::steady_clock::now().time_since_epoch().count());
	return string_hasher(std::uniform_int_distribution<int64_t>(4e10, 5e10)(mt) * 2 + 1);
}

} // namespace string_hasher

namespace euler_walk {

// (vertex index, edge index)
using P = std::pair<int, int>;

struct V {
	int nins;
	std::vector<P> outs;
};

std::optional<std::vector<P>> euler_walk(std::vector<V>& nodes, int M, int src = 0) {
	int c = 0;
	for (auto& n : nodes) {
		c += abs(n.nins - int(n.outs.size()));
	}
	if (c > 2) {
		return std::nullopt;
	}

	int N = int(nodes.size());
	std::vector<std::vector<P>::iterator> its(N);
	for (int i = 0; i < N; i++) {
		its[i] = nodes[i].outs.begin();
	}
	std::vector<char> used(M);
	std::vector<P> res;
	std::vector<P> stk = {P(src, -1)};
	while (!stk.empty()) {
		auto [v, e] = stk.back();

		auto& it = its[v];
		auto end = nodes[v].outs.end();
		while (it != end && used[it->second]) {
			++it;
		}

		if (it == end) {
			res.emplace_back(v, e);
			stk.pop_back();
		} else {
			stk.push_back(*it);
			used[it->second] = true;
		}
	}

	if (int(res.size()) == M+1) {
		reverse(res.begin(), res.end());
		return res;
	} else {
		return std::nullopt;
	}
}

} // namespace euler_walk

using H = string_hasher::string_hasher;
const H base = string_hasher::rand_base();
std::vector<H> pows;

std::pair<std::vector<int>, std::vector<int>> get_map(int M, 
	const std::vector<std::vector<H>>& A, const std::vector<std::vector<H>>& B,
	int d, int& num) {
	int nxt_idx = 0;
	using hash_map_impl::hash_map;
	hash_map<uint64_t, int> mp;
	auto get_idx = [&](uint64_t v) -> int {
		auto it = mp.find(v);
		if (it == mp.end()) {
			it = mp.insert({v, nxt_idx++}).first;
		}
		return it->second;
	};
	int N = int(A.size());
	std::vector<int> res_a(N);
	for (int j = 0; j < N; j++) {
		auto& a = A[j];
		H v = a[d];
		res_a[j] = get_idx(v.get());

	}
	std::vector<int> res_b(N);
	for (int j = 0; j < N; j++) {
		auto& b = B[j];
		H v = H(b[M]) - H(b[M-d]) * pows[d];
		res_b[j] = get_idx(v.get());
	}
	num = nxt_idx;
	return {res_a, res_b};
}

constexpr bool TEST = false;

int rand_int(int a, int b) {
	static std::mt19937_64 mt(std::chrono::steady_clock::now().time_since_epoch().count());
	return std::uniform_int_distribution<int>(a, b)(mt);
}

std::optional<std::pair<std::vector<int>, std::vector<int>>> solve() {
	using namespace std;

	int N, M;
	cin >> N >> M;

	vector<string> A(N);
	vector<string> B(N);

	if constexpr (!TEST) {
		for (auto& a : A) cin >> a;
		for (auto& b : B) cin >> b;
	} else {
		string s;
		for (int i = 0; i < N*M; i++) {
			s += char('a' + rand_int(0, 25));
		}
		int shift = rand_int(0, N*M-1);
		auto t = s;
		rotate(t.begin(), t.begin() + shift, t.end());
		for (int i = 0; i < N*M; i++) {
			int x = i / M;
			A[x] += s[i];
			B[x] += t[i];
		}

		for (int i = 0; i < N; i++) {
			cerr << A[i] << endl;
		}
		for (int i = 0; i < N; i++) {
			cerr << B[i] << endl;
		}
	}

	vector<vector<H>> Ahash(N, vector<H>(M+1));
	for (int j = 0; j < N; j++) {
		Ahash[j][0] = 0;
		for (int i = 0; i < M; i++) {
			Ahash[j][i+1] = Ahash[j][i] * base + H(A[j][i]);
		}
	}
	vector<vector<H>> Bhash(N, vector<H>(M+1));
	for (int j = 0; j < N; j++) {
		Bhash[j][0] = 0;
		for (int i = 0; i < M; i++) {
			Bhash[j][i+1] = Bhash[j][i] * base + H(B[j][i]);
		}
	}

	for (int d = 0; d < M; d++) {
		int L, R;
		auto [A_pref_idx, B_suff_idx] = get_map(M, Ahash, Bhash, d, L);
		auto [B_pref_idx, A_suff_idx] = get_map(M, Bhash, Ahash, M-d, R);

		using euler_walk::V;
		using euler_walk::euler_walk;
		int nedges = 0;
		vector<V> nodes(L+R);
		vector<int> balance(L+R);
		for (int j = 0; j < N; j++) {
			int l = A_pref_idx[j];
			int r = A_suff_idx[j];
			nodes[L+r].nins++;
			nodes[l].outs.emplace_back(L+r, nedges);
			balance[L+r]++;
			balance[l]++;
			nedges++;
		}
		for (int j = 0; j < N; j++) {
			int r = B_pref_idx[j];
			int l = B_suff_idx[j];
			nodes[l].nins++;
			nodes[L+r].outs.emplace_back(l, nedges);
			balance[L+r]--;
			balance[l]--;
			nedges++;
		}

		if ([&]() -> bool {
			for (int v = 0; v < L+R; v++) {
				if (balance[v]) return true;
			}
			return false;
		}()) {
			continue;
		}

		auto res = euler_walk(nodes, nedges);
		if (res) {
			vector<int> P, Q;
			P.reserve(N), Q.reserve(N);
			for (auto [v, e] : *res) {
				if (e < 0) continue;
				if (e < N) {
					P.push_back(e);
				} else if (e < 2*N) {
					Q.push_back(e-N);
				} else assert(false);
			}
			return make_pair(P, Q);
		}
	}
	return std::nullopt;
}

int main() {
	using namespace std;
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	const int L = 1.1e6;
	pows.resize(L);
	pows[0] = 1;
	for (int i = 1; i < L; i++) {
		pows[i] = pows[i-1] * base;
	}

	int T;
	cin >> T;
	while (T--) {
		auto ans = solve();
		if (!ans) {
			cout << -1 << '\n';
		} else {
			const auto& [P, Q] = *ans;
			int N = int(P.size());
			for (const auto& A : {P, Q}) {
				assert(int(A.size()) == N);
				for (int i = 0; i < N; i++) {
					cout << A[i]+1 << " \n"[i+1==N];
				}
			}
		}
	}

	return 0;
}