#include<bits/stdc++.h>

using namespace std;

const long long MOD = 1000000007LL;
const long long INV_2 = 500000004LL;
const int MAX_N = 1000000;


long long FACT[4 * MAX_N + 1];

long long INV_2P[2 * MAX_N + 1];

void init2P() {
	INV_2P[0] = 1LL;
	INV_2P[1] = INV_2;
	
	for (int i = 2; i <= 2 * MAX_N; i++) {
		long long result = INV_2 * INV_2P[i-1];
		result %= MOD;
		INV_2P[i] = result;
	}
}

void initFact() {
	FACT[0] = 1LL;

	for (long long i = 1LL; i <= (long long) (4 * MAX_N); i++) {
		long long result = i * FACT[i-1];
		result %= MOD;
		FACT[i] = result;
	}
}

long long mult(long long a, long long b) {
	return (a * b) % MOD;
}

long long mult(long long a, long long b, long long c) {
	return mult(a, mult(b, c));
}

long long mult(long long a, long long b, long long c, long long d) {
	return mult(mult(a,b), mult(c,d));
}

long long mult(long long a, long long b, long long c, long long d, long long e) {
	return mult(mult(a,b), mult(c,d,e));
}

long long all0or2(int n) {
	long long nl = (long long) n;
	
	long long p1 = mult(nl, FACT[4 * n - 2], INV_2P[2 * n - 1]);
	long long p2 = mult(mult(nl, nl - 1), FACT[4 * n - 2], INV_2P[2 * n - 2]);
	
	return (p1 + p2) % MOD;
}

long long all1s(int n) {
	long long nl = (long long) n;
	
	long long p1 = mult(nl, FACT[4 * n - 3], INV_2P[2 * n - 2]);
	long long p2 = mult(mult(nl, nl - 1), FACT[4 * n - 3], INV_2P[2 * n - 3]);
	long long p = (p1 + p2) % MOD;
	
	return mult(2LL, nl, p);
}

struct Props {
	int sumai;
	int sumsi;
	int beta;
};

Props countsums(const vector<int>& a) {
	int start = 0;
	int mod = 0;
	for (int i = 1; i < a.size(); i++) {
		if (a[i] != a[i-1]) {
			start = i;
			if (a[i] == 2 || a[i-1] == 2) {
				mod = 1;
			}
			break;
		}
	}
	
	int nt2 = a.size() - 1;
	start %= nt2;
	
	int curr_si = 0;
	int sum_si = 0;
	
	int sum_ai = 0;
	int beta = 0;
	bool st = true;

	for (int i = start; i != start || st; i = (i + 1) % nt2) {
		st = false;
		if (a[i] != 1) {
			curr_si = 0;
			if (i % 2 != mod) {
				sum_ai++;
			}
		} else {
			if (i % 2 == mod) {
				curr_si++;
				sum_si += curr_si;
			} else {
				beta++;
			}
		}
	}
	
	Props p = Props();
	p.sumai = sum_ai;
	p.sumsi = sum_si;
	p.beta = beta;
	
	return p;
}

long long calc(int n_int, int alpha_int, long long sumai, long long sumsi, long long beta) {
	long long n = (long long) n_int;
	long long alpha = (long long) alpha_int;
	
	int base_f = 4 * n_int - 2 * alpha_int;
	int base_2 = 2 * n_int - 2 * alpha_int;
	
	long long p1 = mult(alpha, (n - alpha), FACT[base_f - 1], INV_2P[base_2 - 1]);
	long long p2 = mult(alpha, alpha, FACT[base_f - 1], INV_2P[base_2]);
	long long p3_1 = mult(MOD - 1LL, FACT[base_f - 1], INV_2P[base_2 - 1]);
	long long p3_2 = mult(n - alpha - 1, FACT[base_f - 2], INV_2P[base_2 - 2]);
	long long p3_3 = mult(alpha + 1, FACT[base_f - 2], INV_2P[base_2 - 1]);
	long long p3 = mult(sumai, (p3_1 + p3_2 + p3_3) % MOD);
	
	long long p = (p1 + p2 + p3) % MOD;
	
	long long r1 = mult(beta, (n -alpha), FACT[base_f -2], INV_2P[base_2 - 2]);
	long long r2 = mult(beta, alpha, FACT[base_f - 2], INV_2P[base_2 - 1]);
	long long r3_1 = mult(MOD - 1LL, FACT[base_f - 2], INV_2P[base_2 - 2]);
	long long r3_2 = mult(n - alpha - 1, FACT[base_f - 3], INV_2P[base_2 - 3]);
	long long r3_3 = mult(alpha + 1, FACT[base_f - 3], INV_2P[base_2 - 2]);
	long long r3 = mult(sumsi, (r3_1 + r3_2 + r3_3) % MOD);
	
	long long r = (r1 + r2 + r3) % MOD;
	
	return (p + r + MOD) % MOD;
	
}

long long mul(int n) {

	
	bool isValid = true;
		
	vector<int> a(2 * n + 1);
	
	vector<int> counts(3, 0);
	int alpha = 0;
	
	for (int i = 1; i <= 2*n; i++) {
		int ai;
		cin >> ai;
		if (0 <= ai && ai <= 2){
			counts[ai]++;
		}
		
		a[i] = ai;
		
		if (i > 1) {
			if (i % 2 == 0) {
				if (a[i-1] < a[i]){
					isValid = false;
				}
			} else {
				if (a[i-1] > a[i]) {
					isValid = false;
				}
			}
			
			if (a[i] == 1 && a[i-1] != 1) {
				alpha++;
			}
		}
	}
	
	a[0] = a[2 * n];
	
	if (a[0] > a[1]) {
		isValid = false;
	}
	
	if (a[1] == 1 && a[0] != 1) {
		alpha++;
	}
	
	auto sums = countsums(a);
	
	bool seen0 = (counts[0] > 0);
	bool seen1 = (counts[1] > 0);
	bool seen2 = (counts[2] > 0);
	
	if (seen0 && seen2) {
		return 0LL;
	}
	
	if (!seen1) {
		return all0or2(n);
	}
	
	if (!seen0 && seen1 && !seen2) {
		return all1s(n);
	}
	
	if (!isValid) {
		return 0LL;
	}
	
	return calc(n, alpha, sums.sumai, sums.sumsi, sums.beta - alpha);
}

int main() {
	std::ios_base::sync_with_stdio(false);
	std::cin.tie(NULL);
		
	init2P();
	initFact();
	
	int t;
	cin >> t;
	
	for (int it = 0; it < t; it++) {
		int n;
		cin >> n;

		long long result = mul(n);
		cout << result << "\n";
	}

}