#include <bits/stdc++.h>
using namespace std;
#define faster ios_base::sync_with_stdio(false); cin.tie(NULL)
#define Bit(mask , i) ((mask >> i) & 1)
#define fi first
#define se second
#define _LOG2(nl) 31 - __builtin_clz(nl)
#define c_bit(nl) __builtin_popcount(nl)
#define ii pair<long long , int>
#define lll pair<long long , pair<long long , long long>>
#define lii pair<long long , pair<long long , int>>
#define iii pair<int , pair<int , int>>
#define iiii pair<pair<int , int> , pair<int , int>>
#define llll pair<pair<__int128 , __int128> , pair<__int128 , __int128>>
#define li pair<long long , int>
#define db long double
#define onBit(mask , i) (mask | (1 << i))
#define offBit(mask , i) (mask & (~(1 << i)))

const long long INF = 1e16;
const long long MOD = 1e9 + 7;
const db EPS = 1e-12;
const int N = 2e5 + 7;

static int _n;
static std::vector<bool> _a;
static long long num_queries;

static int longest_seq_of_1s(){
    int ans = 0, curr = 0;
    for(int i = 0; i < _n; ++i){
        if(_a[i]){
            ++curr;
        }
        else{
            curr = 0;
        }
        ans = std::max(ans, curr);
    }
    return ans;
}

int flip_bits(const std::vector<bool> &flips){
    assert((int)flips.size() == _n);
    ++num_queries;
    for(int i = 0; i < _n; ++i)
        _a[i] = flips[i] ^ _a[i];
    return longest_seq_of_1s();
}

mt19937 rd(chrono::steady_clock::now().time_since_epoch().count());

int Rand(int l , int r){
    return l + rd() % (r - l + 1);
}

bool check(int st , int L , int cnt , int n){
    vector<bool> tmp;
    tmp.assign(n , 0);

    for (int i = 1 ; i <= cnt ; ++i){
        tmp[st] = 1;
        st += L + 1;
    }

    int cur = flip_bits(tmp);
    if (cur > L){
        cur = flip_bits(tmp);
        return 1;
    }

    cur = flip_bits(tmp);
    return 0;
}

bool Check(int id , int L , int n){
    vector<bool> tmp;
    tmp.assign(n , 0);
    tmp[id] = 1;

    int cur = flip_bits(tmp);

    if (cur > L){
        cur = flip_bits(tmp);
        return 0;
    }

    cur = flip_bits(tmp);
    return 1;
}

pair<int , int> find_longest_subarray_of_ones(int n){
    vector<bool> S;
    S.assign(n , 0);
    int L = flip_bits(S);
    while (L > 15){
        for (int i = 0 ; i < n ; ++i)
            S[i] = Rand(0 , 1);

        L = flip_bits(S);
    }

    if (L == 0) return {-1 , -1};
    if (L == n) return {0 , n - 1};

    for (int i = 0 ; i <= L ; ++i){
        if (check(i , L , n / (L + 1) , n)){
            int l = 1 , r = n / (L + 1) , mid , pos = 0;
            while (l <= r){
                mid = (l + r) >> 1;
                if (check(i + (l - 1) * (L + 1) , L , mid - l + 1 , n)){
                    pos = mid;
                    r = mid - 1;
                }
                else l = mid + 1;
            }
            pos = i + (pos - 1) * (L + 1);

            S.assign(n , 0);
            S[pos] = 1;
            int Length = flip_bits(S);

            l = pos;
            while (l > 0 && Check(l - 1 , Length , n)) --l;
            r = pos;
            while (r < n - 1 && Check(r + 1 , Length , n)) ++r;
            return {l , r};
        }
    }
}

int main(){
    freopen("difmax.inp" , "r" , stdin);
    freopen("difmax.out" , "w" , stdout);
    int t;
    std::cin >> t;

    long long max_qs = 0;

    while(t--){
        num_queries = 0;

        std::cin >> _n;
        _a.resize(_n);
        for(int i = 0; i < _n; ++i){
            bool val;
            std::cin >> val;
            _a[i] = val;
        }

        auto [l, r] = find_longest_subarray_of_ones(_n);
        if (longest_seq_of_1s() == 0 && l == -1 && r == -1){
            cout << "1 \n";
            return 0;
        }
        if(longest_seq_of_1s() != r - l + 1){
            std::cout << "0\n";
            return 0;
        }
        if(l == 0 && r == -1){
            max_qs = std::max(num_queries, max_qs);
            continue;
        }
        if(r < l || l < 0 || l >= _n || r < 0 || r >= _n){
            std::cout << "0\n";
            return 0;
        }

        for(int i = l; i <= r; ++i){
            if(_a[i] != 1){
                std::cout << "0\n";
                return 0;
            }
        }

        max_qs = std::max(num_queries, max_qs);
    }

    if (max_qs > 100) cout << 0 << '\n';
    else std::cout << "1 " << "\n";
    return 0;
}
//
//int main(){
////    freopen("difmax.inp" , "r" , stdin);
////    freopen("difmax.out" , "w" , stdout);
//    faster;
//    inp();
//    solve();
//    return 0;
//}