```go
package main

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

const maxBufferSize = 8 * 1024 * 1024

var scanner *bufio.Scanner
var out *bufio.Writer

func init() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, maxBufferSize), maxBufferSize)
	scanner.Split(bufio.ScanWords)
}

func readInt() int {
	scanner.Scan()
	res := 0
	for _, b := range scanner.Bytes() {
		res = res*10 + int(b-'0')
	}
	return res
}

type Node struct {
	mat [2][2]int
}

var tree []Node

func build(node, l, r int) {
	if l == r {
		tree[node].mat = [2][2]int{{0, 0}, {0, 0}}
		return
	}
	mid := (l + r) / 2
	build(2*node, l, mid)
	build(2*node+1, mid+1, r)
	tree[node].mat = [2][2]int{{0, 0}, {0, 0}}
}

func multiply(A, B [2][2]int) [2][2]int {
	var C [2][2]int
	C[0][0] = (A[0][0] & B[0][0]) | (A[0][1] & B[1][0])
	C[0][1] = (A[0][0] & B[0][1]) | (A[0][1] & B[1][1])
	C[1][0] = (A[1][0] & B[0][0]) | (A[1][1] & B[1][0])
	C[1][1] = (A[1][0] & B[0][1]) | (A[1][1] & B[1][1])
	return C
}

func update(node, l, r, idx, x, y, val int) {
	if l == r {
		tree[node].mat[x][y] = val
		return
	}
	mid := (l + r) / 2
	if idx <= mid {
		update(2*node, l, mid, idx, x, y, val)
	} else {
		update(2*node+1, mid+1, r, idx, x, y, val)
	}
	tree[node].mat = multiply(tree[2*node].mat, tree[2*node+1].mat)
}

func query(node, l, r, ql, qr int) [2][2]int {
	if ql <= l && r <= qr {
		return tree[node].mat
	}
	mid := (l + r) / 2
	if qr <= mid {
		return query(2*node, l, mid, ql, qr)
	}
	if ql > mid {
		return query(2*node+1, mid+1, r, ql, qr)
	}
	return multiply(query(2*node, l, mid, ql, qr), query(2*node+1, mid+1, r, ql, qr))
}

type EdgeInfo struct {
	to         int
	idx        int
	is_forward bool
}

type Event struct {
	val  int
	leaf int
	x    int
	y    int
}

type EventGroup struct {
	val   int
	start int
	end   int
}

func get_val(pos, state, n int, A []int) int {
	if state == 0 {
		return A[pos]
	}
	return A[(pos+n)%(2*n)]
}

func solve() {
	n := readInt()
	A := make([]int, 2*n)
	for i := 0; i < 2*n; i++ {
		A[i] = readInt()
	}

	adj := make([][]EdgeInfo, n)
	for j := 0; j < n; j++ {
		u := (2 * j) % n
		w := (2*j + 1) % n
		adj[u] = append(adj[u], EdgeInfo{to: w, idx: j, is_forward: true})
		adj[w] = append(adj[w], EdgeInfo{to: u, idx: j, is_forward: false})
	}

	visited_vertex := make([]bool, n)
	visited_edge := make([]bool, n)
	var cycles [][]EdgeInfo

	for i := 0; i < n; i++ {
		if !visited_vertex[i] {
			curr := i
			var cycle []EdgeInfo
			for {
				visited_vertex[curr] = true
				moved := false
				for _, edge := range adj[curr] {
					if !visited_edge[edge.idx] {
						visited_edge[edge.idx] = true
						cycle = append(cycle, edge)
						curr = edge.to
						moved = true
						break
					}
				}
				if !moved {
					break
				}
			}
			cycles = append(cycles, cycle)
		}
	}

	num_cycles := len(cycles)
	cycle_start := make([]int, num_cycles)
	cycle_end := make([]int, num_cycles)
	leaf_to_cycle := make([]int, n)
	leaf_is_forward := make([]bool, n)
	edge_to_leaf := make([]int, n)

	leaf_idx := 0
	for c, cycle := range cycles {
		cycle_start[c] = leaf_idx
		for _, edge := range cycle {
			leaf_to_cycle[leaf_idx] = c
			leaf_is_forward[leaf_idx] = edge.is_forward
			edge_to_leaf[edge.idx] = leaf_idx
			leaf_idx++
		}
		cycle_end[c] = leaf_idx - 1
	}

	events := make([]Event, 0, 4*n)
	for j := 0; j < n; j++ {
		leaf := edge_to_leaf[j]
		is_fw := leaf_is_forward[leaf]
		for x := 0; x < 2; x++ {
			for y := 0; y < 2; y++ {
				var val int
				if is_fw {
					val = get_val(2*j, x, n, A) + get_val(2*j+1, y, n, A)
				} else {
					val = get_val(2*j, y, n, A) + get_val(2*j+1, x, n, A)
				}
				events = append(events, Event{val: val, leaf: leaf, x: x, y: y})
			}
		}
	}

	sort.Slice(events, func(i, j int) bool {
		return events[i].val < events[j].val
	})

	groups := make([]EventGroup, 0, 4*n)
	for i := 0; i < len(events); {
		j := i
		for j < len(events) && events[j].val == events[i].val {
			j++
		}
		groups = append(groups, EventGroup{val: events[i].val, start: i, end: j})
		i = j
	}

	if len(tree) < 4*n+10 {
		tree = make([]Node, 4*n+10)
	}
	build(1, 0, n-1)

	valid_cycles := 0
	cycle_status := make([]int, num_cycles)
	affected_seen := make([]bool, num_cycles)
	affected := make([]int, 0, num_cycles)

	ans := int64(3e18)
	p_L := 0
	p_R := 0

	for p_R < len(groups) {
		affected = affected[:0]
		for i := groups[p_R].start; i < groups[p_R].end; i++ {
			ev := events[i]
			update(1, 0, n-1, ev.leaf, ev.x, ev.y, 1)
			c := leaf_to_cycle[ev.leaf]
			if !affected_seen[c] {
				affected_seen[c] = true
				affected = append(affected, c)
			}
		}
		for _, c := range affected {
			mat := query(1, 0, n-1, cycle_start[c], cycle_end[c])
			ns := mat[0][0] | mat[1][1]
			valid_cycles += ns - cycle_status[c]
			cycle_status[c] = ns
			affected_seen[c] = false
		}

		for valid_cycles == num_cycles {
			diff := int64(groups[p_R].val) - int64(groups[p_L].val)
			if diff < ans {
				ans = diff
			}

			affected = affected[:0]
			for i := groups[p_L].start; i < groups[p_L].end; i++ {
				ev := events[i]
				update(1, 0, n-1, ev.leaf, ev.x, ev.y, 0)
				c := leaf_to_cycle[ev.leaf]
				if !affected_seen[c] {
					affected_seen[c] = true
					affected = append(affected, c)
				}
			}
			for _, c := range affected {
				mat := query(1, 0, n-1, cycle_start[c], cycle_end[c])
				ns := mat[0][0] | mat[1][1]
				valid_cycles += ns - cycle_status[c]
				cycle_status[c] = ns
				affected_seen[c] = false
			}
			p_L++
		}
		p_R++
	}

	fmt.Fprintln(out, ans)
}

func main() {
	out = bufio.NewWriter(os.Stdout)
	defer out.Flush()
	t := readInt()
	for i := 0; i < t; i++ {
		solve()
	}
}
```