For problem statement at 0-999/0-99/0-9/5/problemE.txt this is a correct solution, but verifier at 0-999/0-99/0-9/5/verifierE.go ends with case 2 failed: expected 7 got 9
input:5
6 2 7 6 3
exit status 1 can you fix the verifier? ```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var n int
	fmt.Fscan(in, &n)
	h := make([]int64, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &h[i])
	}
	var M int64
	for i := 0; i < n; i++ {
		if h[i] > M {
			M = h[i]
		}
	}
	maxes := []int{}
	for i := 0; i < n; i++ {
		if h[i] == M {
			maxes = append(maxes, i)
		}
	}
	k := len(maxes)
	ans := int64(k) * int64(n-k) + int64(k)*int64(k-1)/2
	for tt := 0; tt < k; tt++ {
		start := maxes[tt] + 1
		end := maxes[(tt+1)%k] - 1
		var temp []int64
		if start <= end {
			temp = h[start : end+1]
		} else {
			if start < n {
				temp = append(temp, h[start:n]...)
			}
			if end >= 0 {
				temp = append(temp, h[0:end+1]...)
			}
		}
		if len(temp) < 2 {
			continue
		}
		ans += computeGood(temp)
	}
	fmt.Println(ans)
}

func computeGood(temp []int64) int64 {
	a := computeSumP(temp)
	rev := make([]int64, len(temp))
	for i := range temp {
		rev[len(temp)-1-i] = temp[i]
	}
	bp := computeSumP(rev)
	eq := computeEqual(temp)
	return a + bp - eq
}

func computeSumP(arr []int64) int64 {
	n := len(arr)
	var res int64
	stack := []int{}
	for i := n - 1; i >= 0; i-- {
		for len(stack) > 0 && arr[stack[len(stack)-1]] <= arr[i] {
			stack = stack[:len(stack)-1]
		}
		p := n
		if len(stack) > 0 {
			p = stack[len(stack)-1]
		}
		res += int64(p - i - 1)
		stack = append(stack, i)
	}
	return res
}

func computeEqual(arr []int64) int64 {
	n := len(arr)
	pg := make([]int, n)
	stack := []int{}
	for i := 0; i < n; i++ {
		for len(stack) > 0 && arr[stack[len(stack)-1]] <= arr[i] {
			stack = stack[:len(stack)-1]
		}
		pg[i] = -1
		if len(stack) > 0 {
			pg[i] = stack[len(stack)-1]
		}
		stack = append(stack, i)
	}
	pos := make(map[int64][]int)
	for i := 0; i < n; i++ {
		pos[arr[i]] = append(pos[arr[i]], i)
	}
	var eq int64
	for i := 0; i < n; i++ {
		v := arr[i]
		list, ok := pos[v]
		if !ok {
			continue
		}
		q := pg[i]
		if q+1 > i-1 {
			continue
		}
		left := sort.SearchInts(list, q+1)
		right := sort.SearchInts(list, i) - 1
		if left <= right {
			eq += int64(right - left + 1)
		}
	}
	return eq
}
```