```go
package main

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

// Standard buffered I/O
var reader *bufio.Reader
var writer *bufio.Writer

func init() {
	reader = bufio.NewReader(os.Stdin)
	writer = bufio.NewWriter(os.Stdout)
}

func readInt() int {
	var x int
	for {
		b, err := reader.ReadByte()
		if err != nil {
			break
		}
		if b >= '0' && b <= '9' {
			x = int(b - '0')
			for {
				b, err = reader.ReadByte()
				if err != nil || b < '0' || b > '9' {
					return x
				}
				x = x*10 + int(b-'0')
			}
		}
	}
	return x
}

func readInt64() int64 {
	var x int64
	for {
		b, err := reader.ReadByte()
		if err != nil {
			break
		}
		if b >= '0' && b <= '9' {
			x = int64(b - '0')
			for {
				b, err = reader.ReadByte()
				if err != nil || b < '0' || b > '9' {
					return x
				}
				x = x*10 + int64(b-'0')
			}
		}
	}
	return x
}

// Matrix representing reachability/compatibility
// mat[prev_edge_state][curr_edge_state]
type Matrix [2][2]bool

func multiply(a, b Matrix) Matrix {
	var res Matrix
	// Standard boolean matrix multiplication: C[i][k] = OR_j (A[i][j] AND B[j][k])
	res[0][0] = (a[0][0] && b[0][0]) || (a[0][1] && b[1][0])
	res[0][1] = (a[0][0] && b[0][1]) || (a[0][1] && b[1][1])
	res[1][0] = (a[1][0] && b[0][0]) || (a[1][1] && b[1][0])
	res[1][1] = (a[1][0] && b[0][1]) || (a[1][1] && b[1][1])
	return res
}

// Segment Tree Nodes
type Node struct {
	mat Matrix
}

var tree []Node
var leafCount int

func buildTree(n int, initial Matrix) {
	leafCount = 1
	for leafCount < n {
		leafCount *= 2
	}
	tree = make([]Node, 2*leafCount)
}

func update(idx int, m Matrix) {
	pos := idx + leafCount
	tree[pos].mat = m
	for pos > 1 {
		pos /= 2
		tree[pos].mat = multiply(tree[2*pos].mat, tree[2*pos+1].mat)
	}
}

func query(l, r int) Matrix {
	// We need product from l to r.
	// Standard iterative segment tree query for non-commutative operation
	var resL, resR Matrix
	// Initialize as Identity matrix
	resL[0][0], resL[1][1] = true, true
	resR[0][0], resR[1][1] = true, true

	l += leafCount
	r += leafCount

	for l <= r {
		if l%2 == 1 {
			resL = multiply(resL, tree[l].mat)
			l++
		}
		if r%2 == 0 {
			resR = multiply(tree[r].mat, resR) // Note order: tree[r] is right side
			r--
		}
		l /= 2
		r /= 2
	}
	return multiply(resL, resR)
}

// Struct to store desk details in linearized order
type DeskInfo struct {
	id          int
	edgeIn      int // Index of edge coming "in" (previous in cycle)
	edgeOut     int // Index of edge going "out" (current in cycle)
	vals        [2][2]int64 // vals[dir_in][dir_out] = sum
}

// Event for sweep-line
type Event struct {
	val     int64
	deskIdx int // Index in linearized array
	dirIn   int
	dirOut  int
}

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

	// Graph construction
	adj := make([][]int, n)
	for i := 0; i < n; i++ {
		// Edge i connects u and v
		u := i / 2       // Desk containing i
		v := (i + n) / 2 // Desk containing i+n
		adj[u] = append(adj[u], i)
		adj[v] = append(adj[v], i)
	}

	// Find cycles
	visitedDesk := make([]bool, n)
	var cycles [][]DeskInfo
	
	for startNode := 0; startNode < n; startNode++ {
		if visitedDesk[startNode] {
			continue
		}
		
		// Trace cycle
		curr := startNode
		var cycleDesks []DeskInfo
		
		// For the first edge, pick any incident
		firstEdge := adj[curr][0]
		currEdge := firstEdge
		
		for {
			visitedDesk[curr] = true
			
			// Edges at curr: e1, e2
			e1 := adj[curr][0]
			e2 := adj[curr][1]
			
			var nextEdge int
			if e1 == currEdge {
				nextEdge = e2
			} else {
				nextEdge = e1
			}
			
			info := DeskInfo{id: curr, edgeIn: currEdge, edgeOut: nextEdge}
			
			slots := []int{2 * curr, 2 * curr + 1}
			edgeIndices := []int{-1, -1}
			
			for k, slotIdx := range slots {
				var eIdx int
				if slotIdx < n {
					eIdx = slotIdx
				} else {
					eIdx = slotIdx - n
				}
				edgeIndices[k] = eIdx
			}
			
			// Compute values
			for dIn := 0; dIn < 2; dIn++ {
				for dOut := 0; dOut < 2; dOut++ {
					var sum int64 = 0
					
					// For each slot, determine which edge controls it
					for k, slotIdx := range slots {
						eIdx := edgeIndices[k]
						var dir int
						
						if eIdx == currEdge {
							dir = dIn
						} else {
							dir = dOut // Must be nextEdge
							if n == 1 {
								if dIn != dOut {
									sum = -1 // Mark invalid
									break
								}
								dir = dIn
							}
						}

						// Calculate value
						var val int64
						isLow := (slotIdx == eIdx)
						
						if dir == 0 {
							val = a[slotIdx]
						} else {
							// swap
							if isLow {
								val = a[slotIdx+n]
							} else {
								val = a[slotIdx-n]
							}
						}
						sum += val
					}
					
					if sum != -1 {
						info.vals[dIn][dOut] = sum
					} else {
						info.vals[dIn][dOut] = -1
					}
				}
			}
			
			cycleDesks = append(cycleDesks, info)
			
			// Move to next node
			u := nextEdge / 2
			v := (nextEdge + n) / 2
			var neighbor int
			if u == curr {
				neighbor = v
			} else {
				neighbor = u
			}
			
			curr = neighbor
			currEdge = nextEdge
			
			if curr == startNode {
				break
			}
		}
		cycles = append(cycles, cycleDesks)
	}

	// Linearize all cycles for SegTree
	type CycleRange struct {
		start, end int // [start, end) in linearized array
	}
	cycleRanges := make([]CycleRange, len(cycles))
	
	var allDesks []DeskInfo
	currentIdx := 0
	
	for i, cyc := range cycles {
		cycleRanges[i] = CycleRange{start: currentIdx, end: currentIdx + len(cyc)}
		allDesks = append(allDesks, cyc...)
		currentIdx += len(cyc)
	}
	
	totalSize := len(allDesks)
	buildTree(totalSize, Matrix{})
	
	// Collect events
	events := make([]Event, 0, 4*totalSize)
	for i, d := range allDesks {
		for r := 0; r < 2; r++ {
			for c := 0; c < 2; c++ {
				v := d.vals[r][c]
				if v != -1 {
					events = append(events, Event{val: v, deskIdx: i, dirIn: r, dirOut: c})
				}
			}
		}
	}
	
	sort.Slice(events, func(i, j int) bool {
		return events[i].val < events[j].val
	})
	
	checkCycle := func(cIdx int) bool {
		r := cycleRanges[cIdx]
		// Special case for cycle length 1
		if r.end - r.start == 1 {
			m := tree[leafCount+r.start].mat
			return m[0][0] || m[1][1]
		}
		
		prod := query(r.start, r.end-1)
		return prod[0][0] || prod[1][1]
	}

	// Re-do loop properly with mapping
	deskToCycle := make([]int, totalSize)
	for cIdx, r := range cycleRanges {
		for k := r.start; k < r.end; k++ {
			deskToCycle[k] = cIdx
		}
	}
	
	// Reset tree (it was empty anyway)
	// We need an array to track if cycle is currently valid
	cycleIsValid := make([]bool, len(cycles))
	
	// 2-pointer loop
	left := 0
	ans := int64(2e18) // Infinity
	
	validCycles := 0
	targetValid := len(cycles)
	
	right := 0
	for left < len(events) {
		// Expand right until valid
		for validCycles < targetValid && right < len(events) {
			e := events[right]
			lIdx := e.deskIdx
			cIdx := deskToCycle[lIdx]
			
			currMat := tree[leafCount + lIdx].mat
			currMat[e.dirIn][e.dirOut] = true
			update(lIdx, currMat)
			
			// Check if this cycle became valid
			if !cycleIsValid[cIdx] {
				if checkCycle(cIdx) {
					cycleIsValid[cIdx] = true
					validCycles++
				}
			}
			right++
		}
		
		if validCycles == targetValid {
			// Update answer
			currDiff := events[right-1].val - events[left].val
			if currDiff < ans {
				ans = currDiff
			}
		} else {
			// Cannot satisfy anymore
			break
		}
		
		// Shrink left
		e := events[left]
		lIdx := e.deskIdx
		cIdx := deskToCycle[lIdx]
		
		currMat := tree[leafCount + lIdx].mat
		currMat[e.dirIn][e.dirOut] = false
		update(lIdx, currMat)
		
		// Check if this cycle became invalid
		if cycleIsValid[cIdx] {
			if !checkCycle(cIdx) {
				cycleIsValid[cIdx] = false
				validCycles--
			}
		}
		
		left++
	}
	
	fmt.Fprintln(writer, ans)
}

func main() {
	defer writer.Flush()
	t := readInt()
	for i := 0; i < t; i++ {
		solve()
	}
}
```