For problem statement at 1000-1999/1600-1699/1650-1659/1651/problemE.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1650-1659/1651/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(reader, &n)

	adj := make([][]int, 2*n+1)
	for i := 1; i <= 2*n; i++ {
		adj[i] = make([]int, 0, 2)
	}

	for i := 0; i < 2*n; i++ {
		var u, v int
		fmt.Fscan(reader, &u, &v)
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	visited := make([]bool, n+1)
	var total_oL int64 = 0

	for i := 1; i <= n; i++ {
		if !visited[i] {
			var U []int
			var V []int

			u_curr := i
			visited[u_curr] = true
			v_curr := adj[u_curr][0]
			U = append(U, u_curr)
			V = append(V, v_curr-n)

			prev_u := u_curr
			curr_v := v_curr

			for {
				next_u := adj[curr_v][0]
				if next_u == prev_u {
					next_u = adj[curr_v][1]
				}
				if next_u == i {
					break
				}
				U = append(U, next_u)
				visited[next_u] = true

				next_v := adj[next_u][0]
				if next_v == curr_v {
					next_v = adj[next_u][1]
				}
				V = append(V, next_v-n)

				prev_u = next_u
				curr_v = next_v
			}

			k := len(U)
			for start := 0; start < k; start++ {
				l_min := U[start]
				l_max := U[start]

				w_L := int64(l_min) * int64(n-l_max+1)
				b1 := V[(start-1+k)%k]
				b2 := V[start]
				x, y := b1, b2
				if x > y {
					x, y = y, x
				}
				L1 := int64(x - 1)
				L2 := int64(y - x - 1)
				L3 := int64(n - y)
				w_R := (L1*(L1+1)/2) + (L2*(L2+1)/2) + (L3*(L3+1)/2)
				total_oL += w_L * w_R

				r_min := V[start]
				r_max := V[start]

				for length := 2; length <= k; length++ {
					j := (start + length - 1) % k
					u_next := U[j]
					if u_next < l_min {
						l_min = u_next
					}
					if u_next > l_max {
						l_max = u_next
					}

					w_L = int64(l_min) * int64(n-l_max+1)

					b1 = V[(start-1+k)%k]
					b2 = V[j]

					if b1 >= r_min && b1 <= r_max {
						w_R = 0
					} else if b2 >= r_min && b2 <= r_max {
						w_R = 0
					} else {
						b_left := 0
						b_right := n + 1

						if b1 < r_min && b1 > b_left {
							b_left = b1
						}
						if b1 > r_max && b1 < b_right {
							b_right = b1
						}

						if b2 < r_min && b2 > b_left {
							b_left = b2
						}
						if b2 > r_max && b2 < b_right {
							b_right = b2
						}

						w_R = int64(r_min-b_left) * int64(b_right-r_max)
					}

					total_oL += w_L * w_R

					v_next := V[j]
					if v_next < r_min {
						r_min = v_next
					}
					if v_next > r_max {
						r_max = v_next
					}
				}
			}
		}
	}

	n64 := int64(n)
	sum_SL := (n64 * (n64 + 1) / 2) * (n64 * (n64 + 1) * (n64 + 2) / 6)
	ans := sum_SL - total_oL

	fmt.Println(ans)
}
```