For problem statement at 1000-1999/1900-1999/1990-1999/1995/problemE1.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1990-1999/1995/verifierE1.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

func desk_sum(k, state_u, state_v, N int, A []int) int {
	p1 := 2*k - 1
	p2 := 2*k

	val1 := 0
	if p1 <= N {
		if state_u == 0 {
			val1 = A[p1]
		} else {
			val1 = A[p1+N]
		}
	} else {
		if state_u == 0 {
			val1 = A[p1]
		} else {
			val1 = A[p1-N]
		}
	}

	val2 := 0
	if p2 <= N {
		if state_v == 0 {
			val2 = A[p2]
		} else {
			val2 = A[p2+N]
		}
	} else {
		if state_v == 0 {
			val2 = A[p2]
		} else {
			val2 = A[p2-N]
		}
	}

	return val1 + val2
}

func eval_sum(k, state_curr, state_nxt, curr_var, nxt_var, N int, A, U, V []int) int {
	u := U[k]
	v := V[k]
	var state_u, state_v int
	if curr_var == u && nxt_var == v {
		state_u = state_curr
		state_v = state_nxt
	} else {
		state_u = state_nxt
		state_v = state_curr
	}
	return desk_sum(k, state_u, state_v, N, A)
}

func check_cycle(cv, ce []int, min_s, max_s, N int, A, U, V []int) bool {
	L := len(cv)
	for start_state := 0; start_state <= 1; start_state++ {
		reach := []int{start_state}
		for j := 0; j < L-1; j++ {
			var next_reach []int
			for _, curr_state := range reach {
				for nxt_state := 0; nxt_state <= 1; nxt_state++ {
					s := eval_sum(ce[j], curr_state, nxt_state, cv[j], cv[j+1], N, A, U, V)
					if min_s <= s && s <= max_s {
						found := false
						for _, x := range next_reach {
							if x == nxt_state {
								found = true
								break
							}
						}
						if !found {
							next_reach = append(next_reach, nxt_state)
						}
					}
				}
			}
			reach = next_reach
		}
		for _, curr_state := range reach {
			s := eval_sum(ce[L-1], curr_state, start_state, cv[L-1], cv[0], N, A, U, V)
			if min_s <= s && s <= max_s {
				return true
			}
		}
	}
	return false
}

func check_all(cvs, ces [][]int, min_s, max_s, N int, A, U, V []int) bool {
	for i := 0; i < len(cvs); i++ {
		if !check_cycle(cvs[i], ces[i], min_s, max_s, N, A, U, V) {
			return false
		}
	}
	return true
}

type Edge struct {
	to  int
	idx int
}

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

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}

	for i := 0; i < t; i++ {
		var N int
		fmt.Fscan(in, &N)

		A := make([]int, 2*N+1)
		for j := 1; j <= 2*N; j++ {
			fmt.Fscan(in, &A[j])
		}

		adj := make([][]Edge, N+1)
		U := make([]int, N+1)
		V := make([]int, N+1)

		for k := 1; k <= N; k++ {
			p1 := 2*k - 1
			p2 := 2*k

			u := p1
			if p1 > N {
				u = p1 - N
			}
			v := p2
			if p2 > N {
				v = p2 - N
			}

			U[k] = u
			V[k] = v
			adj[u] = append(adj[u], Edge{v, k})
			adj[v] = append(adj[v], Edge{u, k})
		}

		var cycles_v [][]int
		var cycles_e [][]int
		visited_edges := make([]bool, N+1)
		visited_verts := make([]bool, N+1)

		for i := 1; i <= N; i++ {
			if visited_verts[i] {
				continue
			}
			curr := i
			var cv []int
			var ce []int
			for {
				cv = append(cv, curr)
				visited_verts[curr] = true
				moved := false
				for _, edge := range adj[curr] {
					if !visited_edges[edge.idx] {
						visited_edges[edge.idx] = true
						ce = append(ce, edge.idx)
						curr = edge.to
						moved = true
						break
					}
				}
				if !moved {
					break
				}
			}
			if len(cv) > 1 {
				cv = cv[:len(cv)-1]
			}
			cycles_v = append(cycles_v, cv)
			cycles_e = append(cycles_e, ce)
		}

		var all_sums []int
		for k := 1; k <= N; k++ {
			for su := 0; su <= 1; su++ {
				for sv := 0; sv <= 1; sv++ {
					all_sums = append(all_sums, desk_sum(k, su, sv, N, A))
				}
			}
		}

		sort.Ints(all_sums)
		var sorted_sums []int
		for j, s := range all_sums {
			if j == 0 || s != all_sums[j-1] {
				sorted_sums = append(sorted_sums, s)
			}
		}

		ans := -1
		ptr := 0
		for j := 0; j < len(sorted_sums); j++ {
			m := sorted_sums[j]
			if ptr < j {
				ptr = j
			}
			for ptr < len(sorted_sums) && !check_all(cycles_v, cycles_e, m, sorted_sums[ptr], N, A, U, V) {
				ptr++
			}
			if ptr < len(sorted_sums) {
				if ans == -1 || sorted_sums[ptr]-m < ans {
					ans = sorted_sums[ptr] - m
				}
			} else {
				break
			}
		}

		fmt.Fprintln(out, ans)
	}
}
```