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

import (
	"io"
	"math"
	"math/bits"
	"os"
	"runtime/debug"
	"sort"
	"strconv"
)

type Pair struct {
	r   int
	idx int
}

type LongQ struct {
	l   int
	r   int
	idx int
}

type PairSlice []Pair

func (p PairSlice) Len() int           { return len(p) }
func (p PairSlice) Less(i, j int) bool { return p[i].r > p[j].r }
func (p PairSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }

func main() {
	debug.SetGCPercent(-1)

	data, _ := io.ReadAll(os.Stdin)
	ptr := 0
	nextInt := func() int {
		for data[ptr] < '0' || data[ptr] > '9' {
			ptr++
		}
		x := 0
		for ptr < len(data) {
			c := data[ptr]
			if c < '0' || c > '9' {
				break
			}
			x = x*10 + int(c-'0')
			ptr++
		}
		return x
	}

	n := nextInt()
	q := nextInt()

	a := make([]int, n+1)
	pos := make([]int, n+1)
	for i := 1; i <= n; i++ {
		v := nextInt()
		a[i] = v
		pos[v] = i
	}

	T := int(float64(n)/math.Sqrt(float64(q))) + 1
	if T < 64 {
		T = 64
	}
	if T > n {
		T = n
	}
	D := 0
	if T < n {
		D = (n - 1) / T
	}

	ans := make([]int, q)

	u := (n + 63) >> 6
	topLen := (u + 63) >> 6
	wordBits := make([]uint64, u)
	top := make([]uint64, topLen)

	solveShort := func(l, r int) int {
		for i := 0; i < topLen; i++ {
			top[i] = 0
		}
		for i := l; i <= r; i++ {
			v := a[i] - 1
			w := v >> 6
			if wordBits[w] == 0 {
				top[w>>6] |= uint64(1) << uint(w&63)
			}
			wordBits[w] |= uint64(1) << uint(v&63)
		}
		res := n
		prev := -1
		for g := 0; g < topLen; g++ {
			z := top[g]
			for z != 0 {
				b := bits.TrailingZeros64(z)
				w := (g << 6) + b
				x := wordBits[w]
				wordBits[w] = 0
				base := w << 6
				for x != 0 {
					t := bits.TrailingZeros64(x)
					cur := base + t + 1
					if prev >= 0 {
						d := cur - prev
						if d < res {
							res = d
						}
					}
					prev = cur
					x &= x - 1
				}
				z &= z - 1
			}
		}
		return res
	}

	longQs := make([]LongQ, 0)
	counts := make([]int, n+2)

	for i := 0; i < q; i++ {
		l := nextInt()
		r := nextInt()
		if r-l+1 <= T {
			ans[i] = solveShort(l, r)
		} else {
			longQs = append(longQs, LongQ{l: l, r: r, idx: i})
			counts[l]++
		}
	}

	if len(longQs) > 0 {
		start := make([]int, n+2)
		for i := 1; i <= n; i++ {
			start[i+1] = start[i] + counts[i]
		}

		pairs := make([]Pair, len(longQs))
		curPos := make([]int, n+2)
		copy(curPos, start)

		for _, qq := range longQs {
			p := curPos[qq.l]
			pairs[p] = Pair{r: qq.r, idx: qq.idx}
			curPos[qq.l] = p + 1
		}

		for l := 1; l <= n; l++ {
			s, e := start[l], start[l+1]
			m := e - s
			if m == 2 {
				if pairs[s].r < pairs[s+1].r {
					pairs[s], pairs[s+1] = pairs[s+1], pairs[s]
				}
			} else if m > 2 {
				sort.Sort(PairSlice(pairs[s:e]))
			}
		}

		ptrs := make([]int, n+2)
		copy(ptrs, start)

		best := make([]int, n+2)
		inf := n + 1
		for i := 1; i <= n; i++ {
			best[i] = inf
		}

		for d := 1; d <= D; d++ {
			limit := n - d
			for v := 1; v <= limit; v++ {
				x := pos[v]
				y := pos[v+d]
				if x < y {
					if y < best[x] {
						best[x] = y
					}
				} else {
					if x < best[y] {
						best[y] = x
					}
				}
			}

			cur := inf
			for l := n - 1; l >= 1; l-- {
				b := best[l]
				if b < cur {
					cur = b
				}
				p := ptrs[l]
				e := start[l+1]
				for p < e && pairs[p].r >= cur {
					ans[pairs[p].idx] = d
					p++
				}
				ptrs[l] = p
			}
		}
	}

	out := make([]byte, 0, q*8)
	for i := 0; i < q; i++ {
		out = strconv.AppendInt(out, int64(ans[i]), 10)
		out = append(out, '\n')
	}
	_, _ = os.Stdout.Write(out)
}