For problem statement at 0-999/600-699/650-659/650/problemD.txt this is a correct solution, but verifier at 0-999/600-699/650-659/650/verifierD.go ends with All tests passed can you fix the verifier? package main

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

type Query struct {
	idx int
	b   int
}

type BIT struct {
	tree []int
}

func newBIT(size int) *BIT {
	return &BIT{tree: make([]int, size+1)}
}

func (b *BIT) update(i int, val int) {
	for ; i < len(b.tree); i += i & -i {
		if val > b.tree[i] {
			b.tree[i] = val
		}
	}
}

func (b *BIT) query(i int) int {
	res := 0
	for ; i > 0; i -= i & -i {
		if b.tree[i] > res {
			res = b.tree[i]
		}
	}
	return res
}

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

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n, m int
	fmt.Fscan(in, &n, &m)

	h := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &h[i])
	}

	queries := make([][]Query, n)
	for i := 0; i < m; i++ {
		var a, b int
		fmt.Fscan(in, &a, &b)
		a--
		queries[a] = append(queries[a], Query{idx: i, b: b})
	}

	pref := make([]int, n)
	dp := make([]int, n+1)
	for i := 1; i <= n; i++ {
		dp[i] = 2e9
	}
	L := 0
	for i := 0; i < n; i++ {
		pos := lowerBound(dp, h[i])
		dp[pos] = h[i]
		pref[i] = pos
		if pos > L {
			L = pos
		}
	}

	suff := make([]int, n)
	for i := 1; i <= n; i++ {
		dp[i] = 2e9
	}
	for i := n - 1; i >= 0; i-- {
		pos := lowerBound(dp, -h[i])
		dp[pos] = -h[i]
		suff[i] = pos
	}

	cnt := make([]int, L+1)
	for i := 0; i < n; i++ {
		if pref[i]+suff[i]-1 == L {
			cnt[pref[i]]++
		}
	}

	essential := make([]int, n)
	for i := 0; i < n; i++ {
		if pref[i]+suff[i]-1 == L && cnt[pref[i]] == 1 {
			essential[i] = 1
		}
	}

	vals := make([]int, 0, n+m)
	for i := 0; i < n; i++ {
		vals = append(vals, h[i])
		for _, q := range queries[i] {
			vals = append(vals, q.b)
		}
	}
	sort.Ints(vals)
	unique := make([]int, 0, len(vals))
	for i := 0; i < len(vals); i++ {
		if i == 0 || vals[i] != vals[i-1] {
			unique = append(unique, vals[i])
		}
	}
	C := len(unique)

	ansPref := make([]int, m)
	bitPref := newBIT(C)
	for i := 0; i < n; i++ {
		for _, q := range queries[i] {
			val := sort.SearchInts(unique, q.b) + 1
			ansPref[q.idx] = bitPref.query(val - 1)
		}
		bitPref.update(sort.SearchInts(unique, h[i])+1, pref[i])
	}

	ansSuff := make([]int, m)
	bitSuff := newBIT(C)
	for i := n - 1; i >= 0; i-- {
		for _, q := range queries[i] {
			val := sort.SearchInts(unique, q.b) + 1
			ansSuff[q.idx] = bitSuff.query(C - val)
		}
		bitSuff.update(C-(sort.SearchInts(unique, h[i])+1)+1, suff[i])
	}

	ans := make([]int, m)
	for i := 0; i < n; i++ {
		for _, q := range queries[i] {
			base := L
			if essential[i] == 1 {
				base = L - 1
			}
			res := ansPref[q.idx] + ansSuff[q.idx] + 1
			if res > base {
				ans[q.idx] = res
			} else {
				ans[q.idx] = base
			}
		}
	}

	for i := 0; i < m; i++ {
		fmt.Fprintln(out, ans[i])
	}
}