For problem statement at 1000-1999/1800-1899/1860-1869/1864/problemF.txt this is a correct solution, but verifier at 1000-1999/1800-1899/1860-1869/1864/verifierF.go ends with All tests passed can you fix the verifier? package main

import (
	"io"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c >= '0' && c <= '9' {
			break
		}
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return val
}

type SegTree struct {
	size int
	t    []int
}

func NewSegTree(n int) *SegTree {
	size := 1
	for size < n {
		size <<= 1
	}
	return &SegTree{size: size, t: make([]int, size<<1)}
}

func (s *SegTree) Update(pos, val int) {
	p := pos + s.size - 1
	s.t[p] = val
	for p >>= 1; p > 0 && s.t[p] < val; p >>= 1 {
		s.t[p] = val
	}
}

func (s *SegTree) Query(l, r int) int {
	if l > r {
		return 0
	}
	l += s.size - 1
	r += s.size - 1
	res := 0
	for l <= r {
		if (l & 1) == 1 {
			if s.t[l] > res {
				res = s.t[l]
			}
			l++
		}
		if (r & 1) == 0 {
			if s.t[r] > res {
				res = s.t[r]
			}
			r--
		}
		l >>= 1
		r >>= 1
	}
	return res
}

func bitAdd(bit []int, idx, val int) {
	for idx < len(bit) {
		bit[idx] += val
		idx += idx & -idx
	}
}

func bitSum(bit []int, idx int) int {
	res := 0
	for idx > 0 {
		res += bit[idx]
		idx -= idx & -idx
	}
	return res
}

func appendInt(buf []byte, x int) []byte {
	if x == 0 {
		return append(buf, '0')
	}
	var tmp [20]byte
	i := len(tmp)
	for x > 0 {
		i--
		tmp[i] = byte('0' + x%10)
		x /= 10
	}
	return append(buf, tmp[i:]...)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data, n: len(data)}

	n := fs.NextInt()
	q := fs.NextInt()

	a := make([]int, n+1)
	cnt := make([]int, n+2)

	for i := 1; i <= n; i++ {
		v := fs.NextInt()
		a[i] = v
		cnt[v]++
	}

	sum := 0
	for v := 1; v <= n+1; v++ {
		c := cnt[v]
		cnt[v] = sum
		sum += c
	}

	cur := make([]int, n+1)
	copy(cur, cnt[:n+1])

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

	headP := make([]int, n+1)
	for i := 0; i <= n; i++ {
		headP[i] = -1
	}
	pairX := make([]int, n)
	pairNext := make([]int, n)
	pairCnt := 0

	seg := NewSegTree(n)
	for x := 1; x <= n; x++ {
		st := cnt[x]
		ed := cnt[x+1]
		if ed-st >= 2 {
			prev := posAll[st]
			for i := st + 1; i < ed; i++ {
				curr := posAll[i]
				if prev+1 <= curr-1 {
					b := seg.Query(prev+1, curr-1)
					if b > 0 {
						pairX[pairCnt] = x
						pairNext[pairCnt] = headP[b]
						headP[b] = pairCnt
						pairCnt++
					}
				}
				prev = curr
			}
		}
		for i := st; i < ed; i++ {
			seg.Update(posAll[i], x)
		}
	}

	prevStart := cnt[1]
	distinct := 0
	for x := 1; x <= n; x++ {
		nextStart := cnt[x+1]
		if nextStart > prevStart {
			distinct++
		}
		cnt[x] = distinct
		prevStart = nextStart
	}

	headQ := make([]int, n+1)
	for i := 0; i <= n; i++ {
		headQ[i] = -1
	}
	qR := make([]int, q)
	qNext := make([]int, q)
	ans := make([]int, q)

	for i := 0; i < q; i++ {
		l := fs.NextInt()
		r := fs.NextInt()
		qR[i] = r
		qNext[i] = headQ[l]
		headQ[l] = i
		ans[i] = cnt[r] - cnt[l-1]
	}

	bit := make([]int, n+2)

	for l := n; l >= 1; l-- {
		for idx := headP[l]; idx != -1; idx = pairNext[idx] {
			bitAdd(bit, pairX[idx], 1)
		}
		for id := headQ[l]; id != -1; id = qNext[id] {
			ans[id] += bitSum(bit, qR[id]) - bitSum(bit, l-1)
		}
	}

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