Problem:
Score : 400 points

Problem Statement

There are two persons, numbered 0 and 1, and a variable x whose initial value is 0.
The two persons now play a game.
The game is played in N rounds. The following should be done in the i-th round (1 \leq i \leq N):

Person S_i does one of the following:

Replace x with x \oplus A_i, where \oplus represents bitwise XOR.

Do nothing.

Person 0 aims to have x=0 at the end of the game, while Person 1 aims to have x \neq 0 at the end of the game.

Determine whether x becomes 0 at the end of the game when the two persons play optimally.

Solve T test cases for each input file.

Constraints

1 \leq T \leq 100

1 \leq N \leq 200

1 \leq A_i \leq 10^{18}

S is a string of length N consisting of 0 and 1.

All numbers in input are integers.

Input

Input is given from Standard Input in the following format.
The first line is as follows:

T

Then, T test cases follow.
Each test case is given in the following format:

N
A_1 A_2 \cdots A_N
S

Output

For each test case, print a line containing 0 if x becomes 0 at the end of the game, and 1 otherwise.

Sample Input 1

3
2
1 2
10
2
1 1
10
6
2 3 4 5 6 7
111000

Sample Output 1

1
0
0

In the first test case, if Person 1 replaces x with 0 \oplus 1=1, we surely have x \neq 0 at the end of the game, regardless of the choice of Person 0.

In the second test case, regardless of the choice of Person 1, Person 0 can make x=0 with a suitable choice.

Solution in Go (1.14.1) (judge verdict: Wrong Answer)

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
)

func out(x ...interface{}) {
	fmt.Println(x...)
}

var sc = bufio.NewScanner(os.Stdin)

func getInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func getString() string {
	sc.Scan()
	return sc.Text()
}

// min, max, asub, absなど基本関数
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func asub(a, b int) int {
	if a > b {
		return a - b
	}
	return b - a
}

func abs(a int) int {
	if a >= 0 {
		return a
	}
	return -a
}

func lowerBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] >= x
	})
	return idx
}

func upperBound(a []int, x int) int {
	idx := sort.Search(len(a), func(i int) bool {
		return a[i] > x
	})
	return idx
}

func bitCount(bits int) int {

	bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555)
	bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333)
	bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f)
	bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff)
	return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff)
}

func check(b []int, s string) (bool, int, int) {
	n := len(b)

	// who have one
	last1 := -1
	pos1 := -1
	pos2 := -1
	for i := n - 1; i >= 0; i-- {
		if b[i] == 1 {
			if s[i] == '0' {
				last1 = 0
				for ; i >= 0; i-- {
					if s[i] == '1' && b[i] == 1 {
						pos2 = i
						break
					}
				}
			} else {
				last1 = 1
				for ; i >= 0; i-- {
					if s[i] == '0' && b[i] == 1 {
						pos2 = i
						break
					}
				}
			}
			pos1 = i
			break
		}
	}
	// out(last1)
	out(b, s, n, last1)
	if last1 == 1 {
		return false, pos1, pos2
	}

	return true, pos1, pos2
}

func solve() {
	N := getInt()
	a := make([]int, N)
	for i := 0; i < N; i++ {
		a[i] = getInt()
	}
	s := getString()

	v := 0
	// out("-----")
	for i := 0; i < N; i++ {
		// out(v)
		if s[i] == '1' {
			d := v ^ a[i]
			// out("1:", v, d)
			if bitCount(v) < bitCount(d) {
				v = d
			}
		} else {
			d := v ^ a[i]
			// out("0:", v, d)
			if bitCount(v) > bitCount(d) {
				v = d
			}
		}
	}
	if v == 0 {
		out("0")
	} else {
		out("1")
	}
	// win0 := true
	// for i := 0; i < 64; i++ {
	// 	b := make([]int, N)
	// 	nonzero := false
	// 	for j := 0; j < N; j++ {
	// 		b[j] = (a[j] >> uint(i)) % 2
	// 		if b[j] == 1 {
	// 			nonzero = true
	// 		}
	// 	}
	// 	if nonzero == true {
	// 		flg, pos1, pos2 := check(b, s)
	// 		out(flg, pos1, pos2)
	// 		if !flg {
	// 			win0 = false
	// 		}
	// 	}
	// }

	// if win0 {
	// 	out(0)
	// } else {
	// 	out(1)
	// }
}

func main() {
	sc.Split(bufio.ScanWords)
	sc.Buffer([]byte{}, 1000000)
	T := getInt()
	for i := 0; i < T; i++ {
		solve()
	}
	//	out(1 << 62)
	// out(int(1e18))
}