For problem statement at 0-999/500-599/540-549/549/problemF.txt this is a correct solution, but verifier at 0-999/500-599/540-549/549/verifierF.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"fmt"
	"io"
	"os"
)

func readInt(b []byte, i int) (int, int) {
	for i < len(b) && (b[i] < '0' || b[i] > '9') {
		i++
	}
	if i >= len(b) {
		return 0, i
	}
	res := 0
	for i < len(b) && b[i] >= '0' && b[i] <= '9' {
		res = res*10 + int(b[i]-'0')
		i++
	}
	return res, i
}

func main() {
	b, _ := io.ReadAll(os.Stdin)
	var n, k, idx int
	n, idx = readInt(b, idx)
	k, idx = readInt(b, idx)

	if n == 0 {
		return
	}

	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i], idx = readInt(b, idx)
	}

	P := make([]int, n+1)
	P[0] = 0
	pos := make([][]int, k)
	pos[0] = append(pos[0], 0)

	for i := 0; i < n; i++ {
		P[i+1] = (P[i] + a[i]%k) % k
		pos[P[i+1]] = append(pos[P[i+1]], i+1)
	}

	L := make([]int, n)
	R := make([]int, n)
	stack := make([]int, 0, n)

	for i := 0; i < n; i++ {
		for len(stack) > 0 && a[stack[len(stack)-1]] <= a[i] {
			stack = stack[:len(stack)-1]
		}
		if len(stack) == 0 {
			L[i] = -1
		} else {
			L[i] = stack[len(stack)-1]
		}
		stack = append(stack, i)
	}

	stack = stack[:0]
	for i := n - 1; i >= 0; i-- {
		for len(stack) > 0 && a[stack[len(stack)-1]] < a[i] {
			stack = stack[:len(stack)-1]
		}
		if len(stack) == 0 {
			R[i] = n
		} else {
			R[i] = stack[len(stack)-1]
		}
		stack = append(stack, i)
	}

	count_in_range := func(target, left, right int) int {
		arr := pos[target]
		if len(arr) == 0 {
			return 0
		}
		
		l, r := 0, len(arr)
		for l < r {
			m := l + (r-l)/2
			if arr[m] >= left {
				r = m
			} else {
				l = m + 1
			}
		}
		lb := l

		l, r = 0, len(arr)
		for l < r {
			m := l + (r-l)/2
			if arr[m] > right {
				r = m
			} else {
				l = m + 1
			}
		}
		ub := l

		return ub - lb
	}

	var ans int64 = 0

	for i := 0; i < n; i++ {
		left_size := i - L[i]
		right_size := R[i] - i

		if left_size <= right_size {
			for x := L[i] + 1; x <= i; x++ {
				target := (P[x] + a[i]%k) % k
				ans += int64(count_in_range(target, i+1, R[i]))
			}
		} else {
			for y := i + 1; y <= R[i]; y++ {
				target := (P[y] - a[i]%k + k) % k
				ans += int64(count_in_range(target, L[i]+1, i))
			}
		}
	}

	fmt.Println(ans - int64(n))
}
```