For problem statement at 0-999/300-399/320-329/321/problemE.txt this is a correct solution, but verifier at 0-999/300-399/320-329/321/verifierE.go ends with case 1 failed: reference runtime error: exec: "refE.bin": executable file not found in $PATH

input:
4 4
0 9 5 6
9 0 3 5
5 3 0 1
6 5 1 0
exit status 1 can you fix the verifier? ```go
package main

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

var (
	n, k     int
	pref     []int
	dpPrev   []int64
	dpCurr   []int64
	costL    int   = 1
	costR    int   = 0
	currCost int64 = 0
)

const INF int64 = 1e18

// getCost moves the global range [costL, costR] to [l, r] efficiently
// and returns the cost of the new range.
func getCost(l, r int) int64 {
	if l > r {
		return 0
	}

	// Move costR to the right
	for costR < r {
		costR++
		if costL <= costR-1 {
			rowOff := costR * (n + 1)
			currCost += int64(pref[rowOff+costR-1] - pref[rowOff+costL-1])
		}
	}
	// Move costL to the left
	for costL > l {
		costL--
		if costL+1 <= costR {
			rowOff := costL * (n + 1)
			currCost += int64(pref[rowOff+costR] - pref[rowOff+costL])
		}
	}
	// Move costR to the left
	for costR > r {
		if costL <= costR-1 {
			rowOff := costR * (n + 1)
			currCost -= int64(pref[rowOff+costR-1] - pref[rowOff+costL-1])
		}
		costR--
	}
	// Move costL to the right
	for costL < l {
		if costL+1 <= costR {
			rowOff := costL * (n + 1)
			currCost -= int64(pref[rowOff+costR] - pref[rowOff+costL])
		}
		costL++
	}
	return currCost
}

// solve uses Divide and Conquer optimization to fill dpCurr
func solve(L, R, optL, optR int) {
	if L > R {
		return
	}

	mid := (L + R) >> 1
	bestP := -1
	minVal := INF

	limit := optR
	if mid-1 < limit {
		limit = mid - 1
	}

	// Iterate split point p
	for p := optL; p <= limit; p++ {
		if dpPrev[p] == INF {
			continue
		}
		val := dpPrev[p] + getCost(p+1, mid)
		if val < minVal {
			minVal = val
			bestP = p
		}
	}

	dpCurr[mid] = minVal
	
	// If no valid p found, default to bounds (though logic implies reachability)
	pRec := bestP
	if pRec == -1 {
		pRec = optL
	}

	solve(L, mid-1, optL, pRec)
	solve(mid+1, R, pRec, optR)
}

func main() {
	// Fast I/O
	scanner := bufio.NewScanner(os.Stdin)
	buf := make([]byte, 256*1024)
	scanner.Buffer(buf, 64*1024*1024) // Handle large input
	scanner.Split(bufio.ScanWords)

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

	if !scanner.Scan() {
		return
	}
	
	// Parse n
	b := scanner.Bytes()
	for _, c := range b {
		n = n*10 + int(c-'0')
	}
	k = readInt()

	// pref[i][j] (flattened) stores sum of u[i][1...j]
	pref = make([]int, (n+1)*(n+1))
	for i := 1; i <= n; i++ {
		rowOff := i * (n + 1)
		sum := 0
		for j := 1; j <= n; j++ {
			val := readInt()
			sum += val
			pref[rowOff+j] = sum
		}
	}

	dpPrev = make([]int64, n+1)
	dpCurr = make([]int64, n+1)

	// Initialize DP
	for i := 1; i <= n; i++ {
		dpPrev[i] = INF
	}
	dpPrev[0] = 0

	// DP transitions
	for j := 1; j <= k; j++ {
		solve(j, n, j-1, n-1)
		copy(dpPrev, dpCurr)
	}

	fmt.Println(dpPrev[n])
}
```