#pragma GCC optimize("O3,unroll-loops,inline")
#include "bits/stdc++.h"
using namespace std;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define all(x) x.begin(),x.end()
#define sz(x) int(x.size())
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;

const ll mod = 1e9+7;
ll mul(ll a, ll b){
    return a*b%mod;
}ll modpow(ll a, ll e) {
    ll ans = 1;
    while(e){
        if (e&1) ans = mul(ans, a);
        a = mul(a,a);
        e/=2;
    }return ans;
}

const int mxN = 4e6+7;
int fact[mxN], ifact[mxN];

ll ncr(int n, int r){
    if (r < 0 or r > n) return 0;
    return mul(fact[n], mul(ifact[r],ifact[n-r]));
}

vi check(vector<array<int,2>> a){
    int n = sz(a)/2;

    vi left(n*2);
    auto rec = [&](int st, int i, auto&& rec, bool start) -> int {
        if (i == st and !start) {
            int two = int(max_element(all(left))-begin(left))%2;
            int mx = -1, mxat = -1;
            rep(i,0,n*2) {
                int cur = (a[i][0] == left[i] ? a[i][1] : a[i][0]);
                if (cur > mx) mx = cur, mxat = i;
            }
            int one = mxat % 2;
            return one + two;
        }
        rep(tk,0,2){
            if (i%2) {
                // want high
                int ans = -1;
                left[i] = a[i][0];
                ans = max(ans, rec(st,(i+1)%(n*2),rec,0));
                left[i] = a[i][1];
                ans = max(ans, rec(st,(i+1)%(n*2),rec,0));
                return ans;
            }else{
                // want low
                int ans = 3;
                left[i] = a[i][0];
                ans = min(ans, rec(st,(i+1)%(n*2),rec,0));
                left[i] = a[i][1];
                ans = min(ans, rec(st,(i+1)%(n*2),rec,0));
                return ans;
            }
        }
    };

    vi sol(n*2);
    rep(i,0,n*2){
        sol[i] = rec(i,i,rec,1);
    }

    return sol;
}

void solve(){
    int n; cin >> n;
    vi a(n*2);
    for(auto& c : a) cin >> c;

    if (count(all(a),0)==n*2 or count(all(a),2)==n*2){
        ll ans = mul(mul(n*2, n*2-1), fact[n*4-2]);
        ans = mul(ans, modpow(2, mod-1-(n*2)));
        cout << ans << '\n';
        return;
    }

    // not 2 and 0 at the same time
    if (count(all(a),0) and count(all(a),2)){
        cout << "0\n";
        return;
    }

    if (count(all(a),1) == n*2){
        // must be big block, 4n is self, but 4n-1, 4n-2 are other
        ll ans = mul(fact[4*n-3], mul(n*2, mul(n*2, n*2-1)));
        ans = mul(ans, modpow(2, mod-1-(n*2)));
        ans = mul(ans, 2); // both players can have max
        cout << ans << '\n';
        return;
    }
    

    if (count(all(a),2)) {
        for(auto& c : a) if (c==2) c = 0;
        rotate(begin(a),begin(a)+1,end(a));
    }

    // now we have only 0 and 1 case

    int st;

    rep(i,0,n*2){
        if (a[i] == 0 and a[(i+1)%(n*2)] == 1){
            if (i%2 == 0){
                cout << "0\n";
                return;
            }else{
                st = i;
            }
        }
    }

    vi onesizes, zerosizes;

    st = (st + 1) % (n*2);
    for(int i = st, beg = 0; i != st or !beg; i = (i+1)%(n*2), beg = 1) {
        {
            int j = i;
            while(a[j] == a[i]) j = (j + 1) % (n*2);
            int len = j - i;
            if (len < 0) len += n*2;
            if (len%2 == 0){
                cout << "0\n"; // ????????????????
                return;
            }
            if (a[i]) onesizes.push_back(len);
            else zerosizes.push_back(len);
            i = (j + n*2 - 1);
        }
    }
    
    ll ans = 0;

    ll div = modpow(2, mod-1-n*2);
    ll segpow = modpow(2, sz(onesizes)*2);

    rep(i,0,sz(onesizes)) {
        // block i contains 4n

        // no special fx
        {
            int K = n*4 - sz(onesizes)*2;
            int s = zerosizes[i];
            // for(int j = 1; j < s-1; j += 2){
            //     // place big one here
            //     // K-1 total ways to place next one
            //     // but j+1 are forbidden <- ACTUALLY, THERES MORE? (s) bad ones? (all to left, and the one free spot where the next segment starts)
            //     ll cur = (K/2) - 1; //- (s); // (K-1) - (j+1)
            //     cur = mul(cur, fact[K-2]);
            //     cur = mul(cur, mul(segpow, div));
            //     cur = mul(cur, 2); // either top or bottom
            //     ans = (ans + cur) % mod;
            // }
            {
                ll cur = mul((K/2) - 1, s/2); //- (s); // (K-1) - (j+1)
                cur = mul(cur, fact[K-2]);
                cur = mul(cur, mul(segpow, div));
                cur = mul(cur, 2); // either top or bottom
                ans = (ans + cur) % mod;
            }

            {
                // otherwise, not to the left -> must be good player to the right 
            // there are (K - 2*(s-1))/2 such positions
                ll cur = (K - 2*(s-1)) / 2;
                cur = mul(cur, fact[K-1]);
                cur = mul(cur, mul(segpow, div));
                ans = (ans + cur) % mod;
            }

            // int bigs = K/2;
            // int left = K/2 - 1;
            // ll cur = mul(bigs, left);
            // cur = mul(cur, fact[K-2]);
            // cur = mul(cur, mul(segpow, div));
            // ans = (ans + cur) % mod;
        }

        // special fx

        {
            int s = onesizes[i];
            int K = n*4 - sz(onesizes)*2;
            
            ll tri = mul(mul(s-1, s+1), (mod+1)/2);

            {
                // inside
                ll cur = mul(tri, (K-2)/2);
                cur = mul(cur, fact[K-3]);
                cur = mul(cur, mul(segpow, div));

                ans = (ans + cur) % mod;
            }

            {
                // outside
                ll cur = mul(s-1, K/2);
                cur = (cur - tri + mod) % mod;
                cur = mul(cur, fact[K-2]);
                cur = mul(cur, mul(segpow, div));

                ans = (ans + cur) % mod;
            }
        }
    }

    cout << ans << '\n';
}

int main(){
    cin.tie(NULL),ios::sync_with_stdio(false);

    fact[0] = 1;
    for(int i = 1; i < mxN; ++i) fact[i] = mul(i, fact[i-1]);
    ifact[mxN-1] = modpow(fact[mxN-1], mod-2);
    for(int i = mxN-1; i > 0; --i) ifact[i-1] = mul(i,ifact[i]);
    
    int t; cin >> t;
    while(t--) solve();
    exit(0);

    int n; cin >> n;
    vector<array<int,2>> a(n*2);
    rep(i,0,n*2) cin >> a[i][0]; 
    rep(i,0,n*2) cin >> a[i][1];

    auto ret = check(a);
    for(auto c : ret) cout << c << ' ';
    cout << '\n';

    // int n; cin >> n;
    // map<vi,int> cnt;

    // vector<array<int,2>> a(n*2);

    // auto rec = [&](int i, auto&& rec, int msk = 0) -> void {
    //     if (i == n*2){
    //         cnt[check(a)]++;
    //         // auto x = check(a);
    //         // if (x == vi{1, 0, 1, 0} and a[0][1] == 5){
    //         //     rep(i,0,n*2) cout << a[i][0] << ' '; cout << '\n';
    //         //     rep(i,0,n*2) cout << a[i][1] << ' '; cout << '\n';
    //         //     cout << '\n';
    //         // }
    //         return;
    //     }

    //     rep(j,0,(n*4)) if (!(msk&(1<<j))) rep(k,j+1,n*4) if (!(msk&(1<<k))) {
    //         a[i] = {j,k};
    //         int nmsk = msk | (1<<j) | (1<<k);
    //         rec(i+1,rec,nmsk);
    //     }
    // };
    // rec(0,rec);

    // for(auto& [k,v] : cnt){
    //     rep(i,0,n*2) cout << k[i] << ' ';
    //     cout << "   " << v << '\n';
    // }
}

/*

4
1 2 3 4 8 5 6 7
15 8 6 9 10


1 1 1 0 0 0 
real 108360
out  88200
diff 20160 -> 4 * 7!

1 1 1 0 1 0
real 11160
out  10080
diff 1080  -> 9 * 5!

1 1 1 0
real 114
out 90
diff 24 -> 4 * 3!

1 1 1 1 1 0
diff 7 * 7!

3
2 3 4 5 6 7
8 1 12 9 10 11

3
2 1 4 3 6 8
7 5 12 9 10 11
*/