For problem statement at 0-999/400-499/450-459/455/problemE.txt this is a correct solution, but verifier at 0-999/400-499/450-459/455/verifierE.go ends with All 100 tests passed can you fix the verifier? ```go
package main

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

type Line struct {
	m int64
	c int64
}

func (l Line) eval(x int64) int64 {
	return l.m*x + l.c
}

type Node struct {
	line Line
	l, r int
}

var tree []Node

func insert(oldRoot int, l, r int, newLine Line) int {
	newNode := len(tree)
	tree = append(tree, tree[oldRoot])

	mid := (l + r) / 2

	betterLeft := newLine.eval(int64(l)) < tree[newNode].line.eval(int64(l))
	betterMid := newLine.eval(int64(mid)) < tree[newNode].line.eval(int64(mid))

	if betterMid {
		tree[newNode].line, newLine = newLine, tree[newNode].line
	}

	if l == r {
		return newNode
	}

	if betterLeft != betterMid {
		tree[newNode].l = insert(tree[newNode].l, l, mid, newLine)
	} else {
		tree[newNode].r = insert(tree[newNode].r, mid+1, r, newLine)
	}

	return newNode
}

func query(root int, l, r int, x int) int64 {
	if root == 0 {
		return 1000000000000000000
	}
	res := tree[root].line.eval(int64(x))
	if l == r {
		return res
	}
	mid := (l + r) / 2
	if x <= mid {
		val := query(tree[root].l, l, mid, x)
		if val < res {
			res = val
		}
	} else {
		val := query(tree[root].r, mid+1, r, x)
		if val < res {
			res = val
		}
	}
	return res
}

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

	readInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}

	res := 0
	for _, b := range scanner.Bytes() {
		res = res*10 + int(b-'0')
	}
	n := res

	a := make([]int64, n+1)
	pref := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		a[i] = int64(readInt())
		pref[i] = pref[i-1] + a[i]
	}

	tree = make([]Node, 1, 3000000)
	tree[0] = Node{line: Line{m: 0, c: 1000000000000000000}, l: 0, r: 0}

	version := make([]int, n+1)
	version[0] = 0

	st := make([]int, 0, n)

	for j := 1; j <= n; j++ {
		for len(st) > 0 && a[st[len(st)-1]] >= a[j] {
			st = st[:len(st)-1]
		}

		k := 0
		if len(st) > 0 {
			k = st[len(st)-1]
		}

		m := -a[j]
		c := int64(j)*a[j] - pref[j-1]

		version[j] = insert(version[k], 1, n, Line{m: m, c: c})
		st = append(st, j)
	}

	m_queries := readInt()

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for q := 0; q < m_queries; q++ {
		xi := readInt()
		yi := readInt()
		L := yi - xi + 1

		ans := pref[yi] + query(version[yi], 1, n, L)
		fmt.Fprintln(out, ans)
	}
}
```