#include <iostream>
#include <string.h>
#include <vector>
using namespace std;

const int MAXN = 100000, MOD = 1000000007;

//Binary indexed tree (also known as Fenwick tree)
int t[MAXN + 10];

void add(int v, int d)
{
	for (; v <= MAXN; v += (v & (-v)))
		t[v] += d;
}

int sum(int r)
{
	int ans = 0;
	for (; r > 0; r -= (r & (-r)))
		ans += t[r];
	return ans;
}

int sum(int l, int r)
{
	return sum(r) - sum(l - 1);
}

//Searching 0-based index of the permutation by given modulo
int index(vector <int> p, int mod)
{
	int n = p.size();
	//Init BIT
	memset(t, 0, sizeof t);
	for (int i = 1; i <= n; ++i)
		add(i, 1);
	//Calculate factorials by given modulo
	int fact[MAXN + 10];
	fact[0] = 1 % mod;
	for (int i = 1; i <= n; ++i)
		fact[i] = fact[i - 1]*1ll*i % mod;
	//Calculate answer
	int ans = 0;
	for (int i = 0; i < n; ++i)
	{
		int id = sum(p[i] - 1);
		ans = (ans + id*1ll*fact[n - 1 - i]) % mod;
		add(p[i], -1);
	}
	return ans;
}

//Searching parity of the permutation
int parity(vector <int> p)
{
	int n = p.size();
	//Init BIT
	memset(t, 0, sizeof t);
	//Calculate answer
	int ans = 0;
	for (int i = n - 1; i >= 0; --i)
	{
		int smaller = sum(p[i] - 1);
		ans = (ans + smaller) % 2;
		add(p[i], 1);
	}
	return ans;
}

int main()
{
	cin.sync_with_stdio(false);
	int CASE;
	cin >> CASE;
	while (CASE--)
	{
		int n, k;
		vector <int> p, q;
		cin >> n >> k;
		p.resize(n);
		q.resize(n);
		for (int i = 0; i < n; ++i)
			cin >> p[i];
		for (int i = 0; i < n; ++i)
			cin >> q[i];
		if (k == n)
		{
			//Look for position where p[0] is stand in permutation q
			int start = -1;
			for (int i = 0; i < n; ++i)
			{
				if (q[i] == p[0])
				{
					start = i;
					break;
				}
			}
			//Check whether permutation q can be obtained from p or not
			bool good = true;
			for (int i = 0; i < n; ++i)
			{
				if (p[i] != q[(i + start) % n])
				{
					good = false;
					break;
				}
			}
			if (good)
				cout << q[0] << endl;
			else
				cout << -1 << endl;
		}
		else if (k % 2 == 0)
		{
			//Permutation q always can be obtained from permutation p
			//Answer is equal to lexicographic index of q
			int id = index(q, MOD);
			cout << (id + 1) % MOD << endl;
		}
		else
		{
			//We need to check if parities of permutations p and q are equal
			if (parity(p) == parity(q))
			{
				//Answer exists
				int id = index(q, MOD);
				//If index is odd, we need to substract 1 from it
				if (index(q, 2) == 1)
					id = (id + MOD - 1) % MOD;
				//500,000,004 is inverse element of 2 by modulo MOD
				id = id*500000004ll % MOD;
				cout << (id + 1) % MOD << endl;
			}
			else
			{
				//Answer doesn't exist
				cout << -1 << endl;
			}
		}
	}
	return 0;
}