For problem statement at 0-999/300-399/360-369/363/problemE.txt this is a correct solution, but verifier at 0-999/300-399/360-369/363/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

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

type MaxCnt struct {
	val int
	cnt int64
}

func merge(a, b MaxCnt) MaxCnt {
	if a.val > b.val {
		return a
	}
	if a.val < b.val {
		return b
	}
	return MaxCnt{a.val, a.cnt + b.cnt}
}

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

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

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

	Grid := make([][]int, n)
	for i := 0; i < n; i++ {
		Grid[i] = make([]int, m)
		for j := 0; j < m; j++ {
			Grid[i][j] = scanInt()
		}
	}

	pref_grid := make([][]int, n)
	for i := 0; i < n; i++ {
		pref_grid[i] = make([]int, m+1)
		for j := 0; j < m; j++ {
			pref_grid[i][j+1] = pref_grid[i][j] + Grid[i][j]
		}
	}

	Y := make([]int, 2*r+1)
	for x := -r; x <= r; x++ {
		v := r*r - x*x
		y := 0
		for (y+1)*(y+1) <= v {
			y++
		}
		Y[x+r] = y
	}

	M := make([]int, 2*r+1)
	for dx := 0; dx <= 2*r; dx++ {
		max_val := -1
		for x := -r + dx; x <= r; x++ {
			val := Y[x+r] + Y[x-dx+r]
			if val > max_val {
				max_val = val
			}
		}
		M[dx] = max_val
	}

	N_prime := n - 2*r
	M_prime := m - 2*r
	if N_prime <= 0 || M_prime <= 0 {
		fmt.Println("0 0")
		return
	}

	A := make([][]int, N_prime)
	for u := 0; u < N_prime; u++ {
		A[u] = make([]int, M_prime)
		for v := 0; v < M_prime; v++ {
			i := u + r
			j := v + r
			sum := 0
			for x := -r; x <= r; x++ {
				row := i + x
				y_max := Y[x+r]
				left := j - y_max
				right := j + y_max
				sum += pref_grid[row][right+1] - pref_grid[row][left]
			}
			A[u][v] = sum
		}
	}

	pref_val := make([][]MaxCnt, N_prime)
	suff_val := make([][]MaxCnt, N_prime)
	for i := 0; i < N_prime; i++ {
		pref_val[i] = make([]MaxCnt, M_prime)
		suff_val[i] = make([]MaxCnt, M_prime)

		curr := MaxCnt{-1, 0}
		for j := 0; j < M_prime; j++ {
			curr = merge(curr, MaxCnt{A[i][j], 1})
			pref_val[i][j] = curr
		}

		curr = MaxCnt{-1, 0}
		for j := M_prime - 1; j >= 0; j-- {
			curr = merge(curr, MaxCnt{A[i][j], 1})
			suff_val[i][j] = curr
		}
	}

	row_max := make([]MaxCnt, N_prime)
	for i := 0; i < N_prime; i++ {
		row_max[i] = pref_val[i][M_prime-1]
	}

	pref_row_max := make([]MaxCnt, N_prime)
	curr := MaxCnt{-1, 0}
	for i := 0; i < N_prime; i++ {
		curr = merge(curr, row_max[i])
		pref_row_max[i] = curr
	}

	suff_row_max := make([]MaxCnt, N_prime)
	curr = MaxCnt{-1, 0}
	for i := N_prime - 1; i >= 0; i-- {
		curr = merge(curr, row_max[i])
		suff_row_max[i] = curr
    }

	max_sum_global := -1
	total_pairs := int64(0)

	for u := 0; u < N_prime; u++ {
		for v := 0; v < M_prime; v++ {
			res := MaxCnt{-1, 0}
			if u-2*r-1 >= 0 {
				res = merge(res, pref_row_max[u-2*r-1])
			}
			if u+2*r+1 < N_prime {
				res = merge(res, suff_row_max[u+2*r+1])
			}

			start_x := u - 2*r
			if start_x < 0 {
				start_x = 0
			}
			end_x := u + 2*r
			if end_x >= N_prime {
				end_x = N_prime - 1
			}

			for x := start_x; x <= end_x; x++ {
				dx := x - u
				if dx < 0 {
					dx = -dx
				}
				limit_y := M[dx]

				left_y := v - limit_y - 1
				if left_y >= 0 {
					res = merge(res, pref_val[x][left_y])
				}

				right_y := v + limit_y + 1
				if right_y < M_prime {
					res = merge(res, suff_val[x][right_y])
				}
			}

			if res.val == -1 {
				continue
			}

			current_sum := A[u][v] + res.val
			if current_sum > max_sum_global {
				max_sum_global = current_sum
				total_pairs = res.cnt
			} else if current_sum == max_sum_global {
				total_pairs += res.cnt
			}
		}
	}

	if total_pairs == 0 {
		fmt.Println("0 0")
	} else {
		fmt.Printf("%d %d\n", max_sum_global, total_pairs/2)
	}
}
```