For problem statement at 1000-1999/1600-1699/1650-1659/1659/problemC.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1650-1659/1659/verifierC.go ends with ok can you fix the verifier? ```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t)

	for tc := 0; tc < t; tc++ {
		var n int
		var a, b int64
		fmt.Fscan(reader, &n, &a, &b)

		x := make([]int64, n+1)
		for i := 1; i <= n; i++ {
			fmt.Fscan(reader, &x[i])
		}

		prefix := make([]int64, n+1)
		for i := 1; i <= n; i++ {
			prefix[i] = prefix[i-1] + x[i]
		}

		dp := make([]int64, n+1)

		type Line struct {
			m, c int64
		}

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

		intersect := func(l1, l2 Line) int64 {
			dc := l1.c - l2.c
			dm := l2.m - l1.m
			if dc >= 0 {
				return 0
			}
			q := dc / dm
			r := dc % dm
			if r == 0 {
				return q
			}
			return q + 1
		}

		lines := make([]Line, 0, n+1)
		lines = append(lines, Line{m: 0, c: 0})

		for i := 1; i <= n; i++ {
			for len(lines) > 1 && eval(lines[1], int64(i)) < eval(lines[0], int64(i)) {
				lines = lines[1:]
			}

			best := eval(lines[0], int64(i))
			dp[i] = b*prefix[i] + a*x[i] + best

			mNew := -b * x[i]
			cNew := dp[i] - b*prefix[i] + b*int64(i)*x[i] - a*x[i]
			newLine := Line{m: mNew, c: cNew}

			for len(lines) >= 2 {
				l1 := lines[len(lines)-2]
				l2 := lines[len(lines)-1]
				if intersect(l2, newLine) <= intersect(l1, l2) {
					lines = lines[:len(lines)-1]
				} else {
					break
				}
			}
			lines = append(lines, newLine)
		}

		var answer int64 = 1 << 62
		for j := 0; j <= n; j++ {
			cost := dp[j]
			if j < n {
				cost += b * (prefix[n] - prefix[j] - int64(n-j)*x[j])
			}
			if cost < answer {
				answer = cost
			}
		}

		fmt.Fprintln(writer, answer)
	}
}
```