#pragma GCC target ("avx2")
#pragma GCC optimize ("unroll-loops")
#pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include <unordered_set>
#include <unordered_map>
#include <random>
using namespace std;
typedef long long ll;
const ll MOD = 1'000'000'007LL; /*998'244'353LL;*/
#define pb push_back
#define mp make_pair
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
const int dx[4]={ 1,0,-1,0 };
const int dy[4]={ 0,1,0,-1 };

template<typename T>
struct Matrix{
    // Arguments
    int H, W;
    T E;
    vector<vector<T>> A;

    // Functions
    Matrix(int h=1, int w=1, T e=0){
        if(h < 1 || w < 1) exit(1);
        H = h; W = w; E = e;
        A.resize(H);
        for(int i=0; i<H; i++){
            A[i].resize(W);
            for(int j=0; j<W; j++){
                A[i][j] = E;
            }
        }
    }
    Matrix(const Matrix<T>& x){
        H = x.H;
        W = x.W;
        E = x.E;
        A.resize(H);
        for(int i=0; i<H; i++){
            A[i].resize(W);
            for(int j=0; j<W; j++){
                A[i][j] = x.A[i][j];
            }
        }
    }
    void resize(int h=1, int w=1, T e=0){
        if(h < 1 || w < 1) exit(1);
        H = h; W = w; E = e;
        A.resize(H);
        for(int i=0; i<H; i++){
            A[i].resize(W);
            for(int j=0; j<W; j++){
                A[i][j] = E;
            }
        }
    }

    // Operators with Matrix
    vector<T>& operator[](int i){ return A[i]; }
    Matrix<T> operator=(const Matrix<T>& x){
        H = x.H;
        W = x.W;
        E = x.E;
        A.resize(H);
        for(int i=0; i<H; i++){
            A[i].resize(W);
            for(int j=0; j<W; j++){
                A[i][j] = x.A[i][j];
            }
        }
        return *this;
    }
    Matrix<T> operator+(const Matrix<T>& x){
        assert(H == x.H && W == x.W && E == x.E);
        Matrix<T> tmp(H, W, E);
        for(int i=0; i<H; i++){
            for(int j=0; j<W; j++){
                tmp.A[i][j] = A[i][j] + x.A[i][j];
            }
        }
        return tmp;
    }
    Matrix<T> operator-(const Matrix<T>& x){
        return (*this)+(-1)*x;
    }
    Matrix<T> operator*(const Matrix<T>& x){
        assert(W == x.H && E == x.E);
        Matrix<T> tmp(H, x.W, 0);
        for(int i=0; i<H; i++){
            for(int j=0; j<x.W; j++){
                for(int k=0; k<W; k++){
                    tmp.A[i][j] += A[i][k] * x.A[k][j];
                }
            }
        }
        return tmp;
    }

    // Operators with Integers
    friend Matrix<T> operator*(const Matrix<T>& a, T b){
        Matrix<T> tmp(a.H, a.W, a.E);
        for(int i=0; i<a.H; i++){
            for(int j=0; j<a.W; j++){
                tmp[i][j] = b * a.A[i][j];
            }
        }
        return tmp;
    }
    friend Matrix<T> operator*(T b, const Matrix<T>& a){
        Matrix<T> tmp(a.H, a.W, a.E);
        for(int i=0; i<a.H; i++){
            for(int j=0; j<a.W; j++){
                tmp[i][j] = b * a.A[i][j];
            }
        }
        return tmp;
    }
};

template<typename T>
void Gauss_Jordan_XOR(Matrix<T> &M){
    int j = 0;
    for(int i=0; i<M.W-1; i++){
        if(M[j][i] == 0){
            for(int k=j+1; k<M.H; k++){
                if(M[k][i] != 0){
                    swap(M[k], M[j]);
                    break;
                }
            }
        }
        if(M[j][i] == 0) continue;
        for(int k=j+1; k<M.H; k++){
            if(M[k][i] != 0){
                for(int l=i; l<M.W; l++){
                    M[k][l] ^= M[j][l];
                }
            }
        }
        j++;
    }
}

template<typename T>
void print(Matrix<T>& M){
    for(int i=0; i<4; i++){
        for(int j=0; j<M.W; j++){
            cout << M[i][j] << " ";
        }
        cout << endl;
    }
    cout << endl;
}

int T;

void solve(){
    int N;
    cin >> N;
    vector<ll> A(N);
    rep(i, N) cin >> A[i];
    string S;
    cin >> S;

    rep(i, N){
        if(S[i] == '1'){
            int cnt = 0;
            for(int j=i+1; j<N; j++){
                if(S[j] == '1') continue;
                cnt++;
            }
            Matrix<int> M(62, cnt+1, 0);
            for(int j=i+1; j<N; j++){
                if(S[j] == '1') continue;
                cnt--;
                rep(k, 62){
                    M[k][cnt] = (A[j]>>k)&1;
                }
            }
            rep(k, 62){
                M[k][M.W-1] = (A[i]>>k)&1;
            }
            //print(M);
            Gauss_Jordan_XOR(M);
            //print(M);
            for(int k=61; k>=0; k--){
                int tmp = 0;
                rep(j, M.W-1){
                    tmp += M[k][j];
                }
                if(tmp >= 1){
                    break;
                }
                if(M[k][M.W-1] == 1){
                    cout << 1 << endl;
                    return;
                }
                
            }
        }
    }
    cout << 0 << endl;
}

signed main(){
	cin >> T;
	while(T--){
        solve();
	}
}

Measured memory_bytes: 3732