#include<iostream>
#include<iomanip>
#include<map>
#include<unordered_map>
#include<set>
#include<vector>
#include<algorithm>
#include<cmath>
#include<string>
#include<queue>
#include<stack>
#include<functional>
#include<tuple>
#include<cctype>

using namespace std;

typedef long double ld;
typedef long long ll;
typedef pair<ll, ll> pii;
typedef pair<ll, bool> pib;

typedef vector<bool> vb;

typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;

typedef vector<double> vf;

typedef queue<ll> qi;

typedef long double ld;

#define mp make_pair
#define mt make_tuple
#define pb push_back

#define rep(i, N) for(ll i = 0; i < N; i++)
#define repa(i, a, N) for(ll i = a; i < N; i++)
#define repr(i, N) for(ll i = N-1; i >= 0; i--)

#define drep(i, N, j, M) rep(i, N) rep(j, M)
#define trep(i, N, j, M, k, L) rep(i, N) rep(j, M) rep(k, L)

#define all(A) A.begin(), A.end()
#define uni(A) A.erase(unique(all(A)), A.end())

template<class t, class u>
ostream& operator<<(ostream& os, const pair<t, u>& p) {
	return os << "{" << p.first << "," << p.second << "}";
}

template<class t>
ostream& operator<<(ostream& os, const vector<t>& v) {
	os << "{";
	for (auto e : v)os << e << ",";
	return os << "}" << endl;
}

template<class t, class u>
ostream& operator<<(ostream& os, const unordered_map<t, u>& m) {
	os << "{";
	for (auto itr = m.begin(); itr != m.end(); ++itr) {
		os << "(" << itr->first << ", " << itr->second << "), ";
	}
	return os << "}";
}

template<class t>
ostream& operator<<(ostream& os, const set<t>& m) {
	os << "{";
	for (auto itr = m.begin(); itr != m.end(); ++itr) {
		os << *itr << ", ";
	}
	return os << "}";
}

template<class t>
ostream& operator<<(ostream& os, const multiset<t>& m) {
	os << "{";
	for (auto itr = m.begin(); itr != m.end(); ++itr) {
		os << *itr << ", ";
	}
	return os << "}";
}

const ll LLMAX = numeric_limits<long long>::max() / 3;
const double DMAX = numeric_limits<double>::max() / 3;

const double PI = 3.141592653589793;
// const ll MOD = 1e9 + 7;
const ll MOD = 998244353;

template <std::int_fast64_t Modulus> class modint {
	using i64 = std::int_fast64_t;

public:
	i64 a;

	constexpr modint(const i64 x = 0) noexcept : a(x % Modulus) {}
	constexpr i64 &value() noexcept { return a; }
	constexpr const i64 &value() const noexcept { return a; }
	constexpr modint operator+(const modint rhs) const noexcept {
		return modint(*this) += rhs;
	}
	constexpr modint operator-(const modint rhs) const noexcept {
		return modint(*this) -= rhs;
	}
	constexpr modint operator*(const modint rhs) const noexcept {
		return modint(*this) *= rhs;
	}
	constexpr modint operator/(const modint rhs) const noexcept {
		return modint(*this) /= rhs;
	}
	constexpr modint &operator+=(const modint rhs) noexcept {
		a += rhs.a;
		if (a >= Modulus) {
			a -= Modulus;
		}
		return *this;
	}
	constexpr modint &operator-=(const modint rhs) noexcept {
		if (a < rhs.a) {
			a += Modulus;
		}
		a -= rhs.a;
		return *this;
	}
	constexpr modint &operator*=(const modint rhs) noexcept {
		a = a * rhs.a % Modulus;
		return *this;
	}
	constexpr modint &operator/=(modint rhs) noexcept {
		i64 exp = Modulus - 2;
		while (exp) {
			if (exp % 2) {
				*this *= rhs;
			}
			rhs *= rhs;
			exp /= 2;
		}
		return *this;
	}
};

template<std::int_fast64_t Modulus>
ostream& operator<<(ostream& os, const modint<Modulus>& m) {
	return os << (m.a + Modulus) % Modulus;
}

typedef modint<MOD> mod;
typedef vector<mod> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;


template<class T> inline bool chmax(T& a, T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> inline bool chmin(T& a, T b) { if (a > b) { a = b; return 1; } return 0; }

void No() { cout << "No" << endl; }
void Yes() { cout << "Yes" << endl; }
void NO() { cout << "NO" << endl; }
void YES() { cout << "YES" << endl; }

vector<ll> fac(1e6+1); //n!(mod M)
vector<ll> ifac(1e6+1); //k!^{M-2} (mod 
ll mpow(ll x, ll n) { //x^n(mod M) ←普通にpow(x,n)では溢れてしまうため，随時mod計算
	ll ans = 1;
	while (n != 0) {
		if (n & 1) ans = ans * x % MOD;
		x = x * x % MOD;
		n = n >> 1;
	}
	return ans;
}

ll comb(ll a, ll b) { //aCbをmod計算
	if (a == 0 && b == 0)return 1;
	if (a < b || a < 0)return 0;
	ll tmp = ifac[a - b] * ifac[b] % MOD;
	return tmp * fac[a] % MOD;
}

void pre_calc_comb() {
	fac[0] = 1;
	ifac[0] = 1;
	for (ll i = 0; i < 1e6; i++) {
		fac[i + 1] = fac[i] * (i + 1) % MOD; // n!(mod M)
		ifac[i + 1] = ifac[i] * mpow(i + 1, MOD - 2) % MOD; // k!^{M-2} (mod M) ←累乗にmpowを採用
	}
}

template <class T> class SegTree {
	int n;
	vector<T> data;
	T def;
	function<T(T, T)> operation;
	function<T(T, T)> update;
	T _query(int a, int b, int k, int l, int r) {
		if (r <= a || b <= l) return def;
		if (a <= l && r <= b)
			return data[k];
		else {
			T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
			T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
			return operation(c1, c2);
		}
	}

public:
	SegTree(size_t _n, T _def, function<T(T, T)> _operation,
		function<T(T, T)> _update)
		: def(_def), operation(_operation), update(_update) {
		n = 1;
		while (n < _n) {
			n *= 2;
		}
		data = vector<T>(2 * n - 1, def);
	}

	void change(int i, T x) {
		i += n - 1;
		data[i] = update(data[i], x);
		while (i > 0) {
			i = (i - 1) / 2;
			data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
		}
	}

	T query(int a, int b) {
		return _query(a, b, 0, 0, n);
	}

	T operator[](int i) {
		return data[i + n - 1];
	}
};

vector< ll > divisor(ll n) {
	vector< ll > ret;
	for (ll i = 1; i * i <= n; i++) {
		if (n % i == 0) {
			ret.push_back(i);
			if (i * i != n) ret.push_back(n / i);
		}
	}
	sort(begin(ret), end(ret));
	return (ret);
}

/*
SegTree<ll> st(N, LLMAX,
    // a: left child, b: right child
	[](ll a, ll b) {return min(a, b); },
	// d: old, x: query
	[](ll d, ll x) {return x; });
// */

ll gcd(ll a, ll b)
{
	if (a == 0)
		return b;
	if (b == 0)
		return a;

	if (a%b == 0)
	{
		return(b);
	}
	else
	{
		return(gcd(b, a%b));
	}
}

ll N, M, K, Q;
ll ans = 0;
ll H, W;

mod num(ll N, ll A) {
	// 0 の個数
	//vvvm dp(N + 1, vvm(A + 1, vm(2)));
	//dp[0][0][0] = 1;
	vvm dp(N + 1, vm(A + 1));

	dp[0][0] = 1;
	rep(i, N) {
		rep(a, A + 1) {
			rep(x, 2) {
				ll na = 0;
				if (a == A) {
					na = A;
				}
				else {
					na = x ? (a + 1) : 0;
				}
				dp[i + 1][na] += dp[i][a];
			}
		}
	}
	return dp[N][A];
}

mod nnum(ll N, ll A, ll B) {
	vvvm dp(N + 1, vvm(A + 1, vm(B + 1)));

	dp[0][0][0] = 1;
	rep(i, N) {
		rep(a, A + 1) {
			rep(b, B + 1) {
				rep(x, 2) {
					ll na, nb;
					if (a == A) {
						na = A;
					}
					else {
						na = x ? (a + 1) : 0;
					}
					if (b == B) {
						nb = B;
					}
					else {
						nb = x ? 0 : (b + 1);
					}

					dp[i + 1][na][nb] += dp[i][a][b];
				}
			}
		}
	}
	return dp[N][A][B];
}


	// i番目の集合には、xをこの数値にすればN番目に0にできるというものの集合
	// N番目の集合 -> 0
	// i番目の集合 -> i + 1番目の集合の要素にできるもの

	// 1が勝つ -> その集合外の数値にできる

	// このままだと、集合は最大で2 ^ Nになるので、 -> TLE
	// 集合の表し方・判定法を高速化する必要がある
	// -> 基底で表すことを考える

	// if(a2 in {a0, a1})
	//    {a0, a1} + {a2} -> {a0, a1, a2}

	// 1 <= Ai <= 1e18 <= 2^60
	// -> 基底の個数は60
	// -> 基底に含まれるかどうかは 2^60 -> TLE

	// 基底を標準化する
	// 1 0 1
	// 1 1 1
	// 0 0 1

    // 2 <- (2 ^ 1)

	// 1 0 1
	// 0 0 1
	// 0 1 0

bool judge(ll a, vi& base) {
	// baseは標準化されているとして、aがbaseで表せるか判定
	for (auto b : base) {
		chmin(a, a^b);
	}

	return a == 0;
}

void Add(ll a, vi& base) {
	// a : 1000
	// base: 
	// 1101
	// 0011

	// 0101
	// 0110

	for (ll i = 0; i < base.size(); i++) {
		ll b = base[i];
		chmin(a, a ^ b);
		if (b < a) {
			base.insert(base.begin() + i, a);
			return;
		}
	}
	base.pb(a);
}


bool solveT() {
	cin >> N;
	ll A[N];
	rep(n, N) {
		cin >> A[n];
	}
	string S;
	cin >> S;

	vi base(0);

	for (ll n = N - 1; n >= 0; n--) {
		ll a = A[n];
		if (judge(a, base))
			continue;

		// 0に出来ない数にすることが可能
		if (S[n] == '1')
			return true;

		// 基底に新たに加える
		Add(a, base);
	}
	return false;
}

void solve() {
	ll T; cin >> T;
	vi A(T);
	rep(t, T) {
		A[t] = solveT();
	}
	rep(t, T) {
		cout << A[t] << endl;
	}
}

int main() {
	solve();
	return 0;
}


Measured memory_bytes: 18584