```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	fmt.Fscan(in, &t)
	const MAXK = 30 // process bits 0..29 (29 is extra high bit)
	for ; t > 0; t-- {
		var n int
		fmt.Fscan(in, &n)
		a := make([]uint64, n-1)
		for i := 0; i < n-1; i++ {
			var x uint64
			fmt.Fscan(in, &x)
			a[i] = x
		}
		b := make([]uint64, n)
		for i := 0; i < n; i++ {
			var x uint64
			fmt.Fscan(in, &x)
			b[i] = x
		}

		req := make([]uint64, n)
		if n >= 2 {
			req[0] = a[0]
			req[n-1] = a[n-2]
			for i := 1; i < n-1; i++ {
				req[i] = a[i-1] | a[i]
			}
		}

		impossible := false
		for i := 1; i < n-1; i++ {
			if ((a[i-1] & a[i+1]) & (^a[i])) != 0 {
				impossible = true
				break
			}
		}
		if impossible {
			fmt.Fprintln(out, -1)
			continue
		}

		// nextZeroFrom[i][pos] = minimal position >= pos where b[i] has bit 0
		nextZeroFrom := make([][MAXK + 2]int, n)
		for i := 0; i < n; i++ {
			// pos MAXK is guaranteed zero (since b < 2^29, bit 29 is 0; pos 30 safe)
			nextZeroFrom[i][MAXK] = MAXK
			for pos := MAXK - 1; pos >= 0; pos-- {
				if ((b[i] >> uint(pos)) & 1) == 0 {
					nextZeroFrom[i][pos] = pos
				} else {
					nextZeroFrom[i][pos] = nextZeroFrom[i][pos+1]
				}
			}
			// For safety, fill pos MAXK+1 as MAXK+1 (unused)
			nextZeroFrom[i][MAXK+1-1] = nextZeroFrom[i][MAXK]
		}

		// hi0: highest bit where req has 1 and b has 0; -1 if none
		hi0 := make([]int, n)
		for i := 0; i < n; i++ {
			mask := req[i] &^ b[i]
			if mask == 0 {
				hi0[i] = -1
			} else {
				// find msb index
				var msb int
				for k := 63; k >= 0; k-- {
					if (mask>>uint(k))&1 == 1 {
						msb = k
						break
					}
				}
				hi0[i] = msb
			}
		}

		hi := make([]int, n)
		for i := 0; i < n; i++ {
			hi[i] = hi0[i]
		}

		// Scan bits from 29 down to 0 (29 is implicit zero in a and req)
		for k := MAXK - 1; k >= 0 && !impossible; k-- {
			for i := 0; i < n-1 && !impossible; i++ {
				var aiBit uint64 = 0
				if k <= 28 {
					aiBit = (a[i] >> uint(k)) & 1
				}
				if aiBit == 1 {
					continue
				}
				reqL := (req[i]>>uint(k))&1 == 1
				reqR := (req[i+1]>>uint(k))&1 == 1

				onesL := reqL || (hi[i] == k) || (hi[i] < k && ((b[i]>>uint(k))&1 == 1))
				onesR := reqR || (hi[i+1] == k) || (hi[i+1] < k && ((b[i+1]>>uint(k))&1 == 1))

				if onesL && onesR {
					if reqL && reqR {
						impossible = true
						break
					} else if reqL {
						if hi[i+1] <= k {
							pos := k
							if hi0[i+1] > pos {
								pos = hi0[i+1]
							}
							h := nextZeroFrom[i+1][pos+1]
							hi[i+1] = h
						}
					} else if reqR {
						if hi[i] <= k {
							pos := k
							if hi0[i] > pos {
								pos = hi0[i]
							}
							h := nextZeroFrom[i][pos+1]
							hi[i] = h
						}
					} else {
						// choose side with smaller next zero > max(k, hi0)
						posL := k
						if hi0[i] > posL {
							posL = hi0[i]
						}
						posR := k
						if hi0[i+1] > posR {
							posR = hi0[i+1]
						}
						hL := nextZeroFrom[i][posL+1]
						hR := nextZeroFrom[i+1][posR+1]
						if hL <= hR {
							hi[i] = hL
						} else {
							hi[i+1] = hR
						}
					}
				}
			}
		}
		if impossible {
			fmt.Fprintln(out, -1)
			continue
		}

		// Build x and verify
		x := make([]uint64, n)
		for i := 0; i < n; i++ {
			if hi[i] < 0 {
				x[i] = b[i]
			} else {
				hiu := uint(hi[i])
				topMask := ^((uint64(1) << (hiu + 1)) - 1)
				top := b[i] & topMask
				bit := uint64(1) << hiu
				lowMask := (uint64(1) << hiu) - 1
				low := req[i] & lowMask
				x[i] = top + bit + low
			}
		}
		ok := true
		for i := 0; i < n-1; i++ {
			if (x[i] & x[i+1]) != a[i] {
				ok = false
				break
			}
		}
		if !ok {
			fmt.Fprintln(out, -1)
			continue
		}
		var ans uint64 = 0
		for i := 0; i < n; i++ {
			if x[i] >= b[i] {
				ans += x[i] - b[i]
			} else {
				ok = false
				break
			}
		}
		if !ok {
			fmt.Fprintln(out, -1)
			continue
		}
		fmt.Fprintln(out, ans)
	}
}
```