For problem statement at 1000-1999/1900-1999/1900-1909/1905/problemF.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1900-1909/1905/verifierF.go ends with All 100 tests passed can you fix the verifier? package main

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

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func upperBound(a []int, val int) int {
	l, r := 0, len(a)
	for l < r {
		m := l + (r-l)/2
		if a[m] > val {
			r = m
		} else {
			l = m + 1
		}
	}
	return l
}

func lowerBound(a []int, val int) int {
	l, r := 0, len(a)
	for l < r {
		m := l + (r-l)/2
		if a[m] >= val {
			r = m
		} else {
			l = m + 1
		}
	}
	return l
}

func solve(in *bufio.Reader, out *bufio.Writer) {
	var t int
	fmt.Fscan(in, &t)
	for tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(in, &n)
		p := make([]int, n+1)
		pos := make([]int, n+1)
		for i := 1; i <= n; i++ {
			fmt.Fscan(in, &p[i])
			pos[p[i]] = i
		}

		M1 := make([]int, n+1)
		M2 := make([]int, n+1)
		m1, m2 := 0, 0
		for i := 1; i <= n; i++ {
			if p[i] > m1 {
				m2 = m1
				m1 = p[i]
			} else if p[i] > m2 {
				m2 = p[i]
			}
			M1[i] = m1
			M2[i] = m2
		}

		G0 := make([]int, 0)
		S := make([][]int, n+1)
		c := make([]int, n+1)
		k := make([]int, n+1)

		for x := 1; x <= n; x++ {
			if p[x] == x {
				if M1[x-1] < x {
					G0 = append(G0, x)
				} else if M1[x-1] > x && M2[x-1] < x {
					c[x] = 1
					k[x] = pos[M1[x-1]]
					S[k[x]] = append(S[k[x]], x)
				}
			}
		}

		sufMin := make([]int, n+2)
		sufMin[n+1] = n + 1
		sufMinPos := make([]int, n+2)
		for i := n; i >= 1; i-- {
			if p[i] < sufMin[i+1] {
				sufMin[i] = p[i]
				sufMinPos[i] = i
			} else {
				sufMin[i] = sufMin[i+1]
				sufMinPos[i] = sufMinPos[i+1]
			}
		}

		type pair struct{ i, j int }
		candidates := make([]pair, 0, 2*n)

		for v := 1; v <= n; v++ {
			i := min(v, pos[v])
			j := max(v, pos[v])
			if i < j {
				candidates = append(candidates, pair{i, j})
			}
		}

		for x := 1; x <= n; x++ {
			if p[x] == x && c[x] == 1 {
				i := k[x]
				if x+1 <= n {
					j := sufMinPos[x+1]
					if i < j {
						candidates = append(candidates, pair{i, j})
					}
				}
			}
		}

		if len(candidates) == 0 {
			candidates = append(candidates, pair{1, 2})
		} else {
			sort.Slice(candidates, func(a, b int) bool {
				if candidates[a].i != candidates[b].i {
					return candidates[a].i < candidates[b].i
				}
				return candidates[a].j < candidates[b].j
			})
			uniqueCandidates := []pair{candidates[0]}
			for iter := 1; iter < len(candidates); iter++ {
				if candidates[iter] != candidates[iter-1] {
					uniqueCandidates = append(uniqueCandidates, candidates[iter])
				}
			}
			candidates = uniqueCandidates
		}

		maxGood := -1

		for _, cand := range candidates {
			i := cand.i
			j := cand.j
			score := 0

			itBefore := lowerBound(G0, i)
			score += itBefore

			itAfter := upperBound(G0, j)
			score += len(G0) - itAfter

			if p[j] == i && M1[i-1] < i {
				score++
			}

			maxExcl := M1[j-1]
			if p[i] == M1[j-1] {
				maxExcl = M2[j-1]
			}
			if p[i] == j && maxExcl < j && p[j] < j {
				score++
			}

			L := max(i, p[j])
			R := j

			if L < R {
				it1 := upperBound(G0, L)
				it2 := lowerBound(G0, R)
				if it1 < it2 {
					score += it2 - it1
				}

				sList := S[i]
				if len(sList) > 0 {
					it1 = upperBound(sList, L)
					it2 = lowerBound(sList, R)
					if it1 < it2 {
						score += it2 - it1
					}
				}
			}

			if score > maxGood {
				maxGood = score
			}
		}

		fmt.Fprintln(out, maxGood)
	}
}

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