```go
package main

import (
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) skip() {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
}

func (fs *FastScanner) NextUint64() uint64 {
	fs.skip()
	var v uint64
	for fs.idx < len(fs.data) {
		b := fs.data[fs.idx]
		if b < '0' || b > '9' {
			break
		}
		v = v*10 + uint64(b-'0')
		fs.idx++
	}
	return v
}

func (fs *FastScanner) NextString() string {
	fs.skip()
	start := fs.idx
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		fs.idx++
	}
	return string(fs.data[start:fs.idx])
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	t := int(fs.NextUint64())
	out := make([]byte, 0, t*24)

	for ; t > 0; t-- {
		n := int(fs.NextUint64())

		a := make([]uint64, n)
		d := make([]uint64, n)

		var base uint64
		for i := 0; i < n; i++ {
			a[i] = fs.NextUint64()
			base ^= a[i]
		}
		for i := 0; i < n; i++ {
			b := fs.NextUint64()
			d[i] = a[i] ^ b
		}
		c := fs.NextString()

		var basis [60]uint64
		var owner [60]byte

		for i := n - 1; i >= 0; i-- {
			v := d[i]
			for bit := 59; bit >= 0 && v != 0; bit-- {
				if ((v >> uint(bit)) & 1) == 0 {
					continue
				}
				if basis[bit] == 0 {
					basis[bit] = v
					owner[bit] = c[i]
					break
				}
				v ^= basis[bit]
			}
		}

		ans := base
		for bit := 59; bit >= 0; bit-- {
			if basis[bit] == 0 {
				continue
			}
			cur := (ans >> uint(bit)) & 1
			if owner[bit] == '0' {
				if cur == 1 {
					ans ^= basis[bit]
				}
			} else {
				if cur == 0 {
					ans ^= basis[bit]
				}
			}
		}

		out = strconv.AppendUint(out, ans, 10)
		out = append(out, '\n')
	}

	_, _ = os.Stdout.Write(out)
}
```