#include <bits/stdc++.h>
using namespace std;

constexpr int mod = 1e9 + 7;

class ModNum {

 public:
  ModNum(int a) : a_(a) {}

  ModNum& operator+=(const ModNum& other) {
    a_ += other.a_;
    a_ = (a_ >= mod) ? a_ - mod : a_;
    return (*this);
  }

  friend ModNum operator+(ModNum lhs, const ModNum& rhs) {
    return (lhs += rhs);
  }

  ModNum& operator*=(const ModNum& other) {
    a_ = static_cast<int>(a_ * static_cast<long long>(other.a_) % mod);
    return (*this);
  }

  friend ModNum operator*(ModNum lhs, const ModNum& rhs) {
    return (lhs *= rhs);
  }

  ModNum exp(int x) const {
    if (x == 0) {
      return 1;
    }
    if (x & 1) {
      return exp(x-1) * (*this);
    }
    return ((*this) * (*this)).exp(x / 2);
  }

  static ModNum inv_two() {
    return (mod + 1) / 2;
  }

  int get() const {
    return a_;
  }

 private:
  int a_;
};
vector<ModNum> factorial() {
  static constexpr int N = 4e6 + 5;
  vector<ModNum> ans(N+1, 1);
  for (int i = 2; i <= N; i++) {
    ans[i] = ans[i-1] * i;
  }
  return ans;
}


ModNum factorial(int n) {
  static vector<ModNum> fact = factorial();
  if (n < 0) {
    return 0;
  }
  return fact[n];
}

bool check_range(vector<int>& arr) {
  int min_ = 2, max_ = 0;
  for (int v : arr) {
    min_ = min(min_, v);
    max_ = max(max_, v);
  }
  if (max_ - min_ == 2) {
    return false;
  }
  if (max_ == 2) {
    rotate(arr.begin(), arr.begin() + 1, arr.end());
    for (int& v : arr) {
      if (v == 2) {
        v = 0;
      }
    }
  }
  return true;
}

bool solve_for_zeros(const vector<int>& arr) {
  int n = arr.size() / 2;
  int cnt = 0;
  for (int v : arr) {
    cnt += (v == 0);
  }
  if (cnt < (int) arr.size()) {
    return false;
  }
  ModNum res = 1;
  res *= 2*n;
  res *= 2*n - 1;
  res *= factorial(4*n-2);
  res *= ModNum((mod+1)/2).exp(2*n);
  cout << res.get() << endl;
  return true;
}

bool solve_for_ones(const vector<int>& arr) {
  int n = arr.size() / 2;
  int cnt = 0;
  for (int v : arr) {
    cnt += (v == 1);
  }
  if (cnt < (int) arr.size()) {
    return false;
  }
  ModNum res = 1;
  res *= 4*n;
  res *= 2*n;
  res *= (2*n - 1);
  for (int i = 1; i <= 4*n - 3; i++) {
    res *= i;
  }
  // cout << res.get() << "\n";
  res *= ModNum::inv_two().exp(2*n);
  cout << res.get() << "\n";
  return true;
}

bool check_parity(const vector<int>& arr) {
  for (int i = 0; i < (int) arr.size() - 1; i++) {
    if (i % 2 == 0 && arr[i] == 0 && arr[i+1] == 1) {
      return false;
    }
    else if (i % 2 == 1 && arr[i] == 1 && arr[i+1] == 0) {
      return false;
    }
  }
  if (arr.back() == 1 && arr.front() == 0) {
    return false;
  }
  return true;
}



bool init(vector<int>& arr) {
  if (!check_range(arr)) {
    return false;
  }
  if (!check_parity(arr)) {
    return false;
  }
  return true;
}

ModNum case1(int n, const vector<int>& segments) {
  int S = (int) segments.size() / 2;
  ModNum base = ModNum(2).exp(2*S + 1);
  base *= (2*n - S - 1);
  base *= factorial(4*n - 2*S - 2);

  ModNum sum_ = 0;
  for (int i = 0; i < (int) segments.size(); i += 2) {
    sum_ += segments[i] / 2;
  }
  ModNum ans = base * sum_;
  // cerr << "[CASE #1] " << ans.get() << endl;
  return ans;
}

ModNum case2(int n, const vector<int>& segments) {
  int S = (int) segments.size() / 2;
  ModNum base = ModNum(2).exp(2*S);
  base *= factorial(4*n-2*S-1);
  ModNum sum_ = 0;
  for (int i = 0; i < (int) segments.size(); i += 2) {
    sum_ += (2*n - (segments[i] / 2) * 2 - S);
  }
  ModNum ans = base * sum_;
  // cerr << "[CASE #2] " << ans.get() << endl;
  return ans;
}

template<typename T>
ModNum sum_even(int n, const T& func) {
  ModNum ans = 0;
  for (int i = 2; i <= n; i+= 2) {
    ans += func(i);
  }
  return ans;
}

ModNum case3(int n, const vector<int>& segments) {
  int S = (int) segments.size() / 2;
  ModNum base = ModNum(2).exp(2*S + 1);
  base *= (2*n - S - 1);
  base *= factorial(4*n - 2*S - 3);
  ModNum sum_ = 0;
  for (int i = 1; i < (int) segments.size(); i += 2) {
    sum_ += sum_even(segments[i], [](int k) { return k; });
  }
  ModNum ans = base * sum_;
  // cerr << "[CASE #3] " << ans.get() << endl;
  return ans;
}

ModNum case4(int n, const vector<int>& segments) {
  int S = (int) segments.size() / 2;
  ModNum base = ModNum(2).exp(2*S+1);
  // cerr << "[PHASE 1] " << base.get() << endl;
  base *= factorial(4*n - 2*S - 2);
  // cerr << "[PHASE 2] " << base.get() << endl;
  ModNum sum_ = 0;
  for (int i = 1; i < (int) segments.size(); i += 2) {
    sum_ += sum_even(segments[i], [n, S](int k) { return (2*n - k - S); });
  }
  ModNum ans = base * sum_;
  // cerr << "[CASE #4] " << ans.get() << endl;
  return ans;
}



void solve() {
  int n;
  cin >> n;
  vector<int> arr(2*n);
  for (int& v : arr) {
    cin >> v;
  }
  if (!init(arr)) {
    cout << 0 << "\n";
    return;
  }

  if (solve_for_ones(arr)) {
    return;
  }
  if (solve_for_zeros(arr)) {
    return;
  }
  for (int i = 1; i < 2*n; i++) {
    if (arr[i-1] == 1 && arr[i] == 0) {
      rotate(arr.begin(), arr.begin()+i, arr.end());
      break;
    }
  }
  vector<int> segments;
  int cnt = 1;
  for (int i = 1; i < 2*n; i++) {
    if (arr[i] != arr[i-1]) {
      segments.push_back(cnt);
      cnt = 0;
    }
    cnt++;
  }
  // segments starting with zeros.
  segments.push_back(cnt);

  // cerr << "[DEBUG SEGMENTS] ";
  // for (int v : segments) {
  //   cerr << v << ", ";
  // }
  // cerr << endl;

  ModNum res = case1(n, segments) + case2(n, segments) + case3(n, segments) + case4(n, segments);
  res *= ModNum((mod + 1) / 2).exp(2*n);
  cout << res.get() << "\n";
}


int main() {
  int t;
  cin >> t;
  while (t--) {
    solve();
  }
}