For problem statement at 1000-1999/1400-1499/1480-1489/1488/problemF.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1480-1489/1488/verifierF.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"os"
	"strconv"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024)

	nextInt := func() int {
		scanner.Scan()
		n, _ := strconv.Atoi(scanner.Text())
		return n
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())

	c := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		c[i] = int64(nextInt())
	}

	q := nextInt()

	type Query struct {
		l   int
		idx int
	}
	queries := make([][]Query, n+1)
	for i := 0; i < q; i++ {
		l := nextInt()
		r := nextInt()
		queries[r] = append(queries[r], Query{l, i})
	}

	ans := make([]int64, q)
	bit1 := make([]int64, n+2)
	bit2 := make([]int64, n+2)

	add := func(p int, v int64) {
		for i := p; i <= n; i += i & -i {
			bit1[i] += v
			bit2[i] += int64(p) * v
		}
	}

	rangeAdd := func(l, r int, v int64) {
		add(l, v)
		add(r+1, -v)
	}

	query := func(p int) int64 {
		var s1, s2 int64
		for i := p; i > 0; i -= i & -i {
			s1 += bit1[i]
			s2 += bit2[i]
		}
		return s1*int64(p+1) - s2
	}

	rangeQuery := func(l, r int) int64 {
		return query(r) - query(l-1)
	}

	var stack []int
	for r := 1; r <= n; r++ {
		for len(stack) > 0 && c[stack[len(stack)-1]] <= c[r] {
			j := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			prev := 0
			if len(stack) > 0 {
				prev = stack[len(stack)-1]
			}
			rangeAdd(prev+1, j, c[r]-c[j])
		}
		rangeAdd(r, r, c[r])
		stack = append(stack, r)

		for _, qry := range queries[r] {
			ans[qry.idx] = rangeQuery(qry.l, r)
		}
	}

	writer := bufio.NewWriter(os.Stdout)
	for i := 0; i < q; i++ {
		writer.WriteString(strconv.FormatInt(ans[i], 10))
		writer.WriteByte('\n')
	}
	writer.Flush()
}
```