For problem statement at 1000-1999/1900-1999/1910-1919/1913/problemF.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1910-1919/1913/verifierF.go ends with All 100 tests passed can you fix the verifier? package main

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024*10)
	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	if !scanner.Scan() {
		return
	}
	s := scanner.Text()

	d1 := make([]int, n)
	l, r := 0, -1
	for i := 0; i < n; i++ {
		k := 1
		if i <= r {
			j := l + r - i
			if j >= 0 && d1[j] < r-i+1 {
				k = d1[j]
			} else {
				k = r - i + 1
			}
		}
		for i-k >= 0 && i+k < n && s[i-k] == s[i+k] {
			k++
		}
		d1[i] = k
		if i+k-1 > r {
			l = i - k + 1
			r = i + k - 1
		}
	}

	d2 := make([]int, n)
	l, r = 0, -1
	for i := 0; i < n; i++ {
		k := 0
		if i < r {
			j := l + r - i - 1
			if j >= 0 && d2[j] < r-i {
				k = d2[j]
			} else {
				k = r - i
			}
		}
		for i-k >= 0 && i+k+1 < n && s[i-k] == s[i+k+1] {
			k++
		}
		d2[i] = k
		if i+k > r {
			l = i - k + 1
			r = i + k
		}
	}

	base := int64(0)
	for i := 0; i < n; i++ {
		base += int64(d1[i])
		base += int64(d2[i])
	}

	D2 := make([]int32, n+5)

	addAP1 := func(A, B int) {
		if A > B {
			return
		}
		L := int32(B - A + 1)
		D2[A] += 1
		D2[B+1] -= L + 1
		D2[B+2] += L
	}

	addAP2 := func(A, B int) {
		if A > B {
			return
		}
		L := int32(B - A + 1)
		D2[A] += L
		D2[A+1] -= L + 1
		D2[B+2] += 1
	}

	M := make([]int32, n)
	for i := 0; i < n; i++ {
		R := d1[i] - 1
		addAP1(i-R, i)
		addAP2(i+1, i+R)
		M[i] += int32(R + 1)

		R2 := d2[i]
		addAP1(i-R2+1, i)
		addAP2(i+1, i+R2)
	}

	C := make([]int32, n)
	curD := int32(0)
	curC := int32(0)
	for i := 0; i < n; i++ {
		curD += D2[i]
		curC += curD
		C[i] = curC
	}

	const B1 = 313
	const M1 = 1000000007
	const B2 = 317
	const M2 = 1000000009

	P1 := make([]int64, n+1)
	P2 := make([]int64, n+1)
	H1_1 := make([]int64, n+1)
	H1_2 := make([]int64, n+1)
	H2_1 := make([]int64, n+1)
	H2_2 := make([]int64, n+1)

	P1[0] = 1
	P2[0] = 1
	for i := 1; i <= n; i++ {
		P1[i] = (P1[i-1] * B1) % M1
		P2[i] = (P2[i-1] * B2) % M2
	}

	for i := 0; i < n; i++ {
		H1_1[i+1] = (H1_1[i]*B1 + int64(s[i])) % M1
		H1_2[i+1] = (H1_2[i]*B2 + int64(s[i])) % M2
	}

	for i := n - 1; i >= 0; i-- {
		H2_1[i] = (H2_1[i+1]*B1 + int64(s[i])) % M1
		H2_2[i] = (H2_2[i+1]*B2 + int64(s[i])) % M2
	}

	getH1 := func(l, r int) (int64, int64) {
		if l > r {
			return 0, 0
		}
		v1 := (H1_1[r+1] - H1_1[l]*P1[r-l+1]) % M1
		if v1 < 0 {
			v1 += M1
		}
		v2 := (H1_2[r+1] - H1_2[l]*P2[r-l+1]) % M2
		if v2 < 0 {
			v2 += M2
		}
		return v1, v2
	}

	getH2 := func(l, r int) (int64, int64) {
		if l > r {
			return 0, 0
		}
		v1 := (H2_1[l] - H2_1[r+1]*P1[r-l+1]) % M1
		if v1 < 0 {
			v1 += M1
		}
		v2 := (H2_2[l] - H2_2[r+1]*P2[r-l+1]) % M2
		if v2 < 0 {
			v2 += M2
		}
		return v1, v2
	}

	getE := func(L, R_idx int) int {
		low := 1
		high := L
		if n-1-R_idx < high {
			high = n - 1 - R_idx
		}
		ans := 0
		for low <= high {
			mid := (low + high) / 2
			v1_1, v1_2 := getH1(R_idx+1, R_idx+mid)
			v2_1, v2_2 := getH2(L-mid, L-1)
			if v1_1 == v2_1 && v1_2 == v2_2 {
				ans = mid
				low = mid + 1
			} else {
				high = mid - 1
			}
		}
		return ans
	}

	created := make([]int32, n*26)

	for i := 0; i < n; i++ {
		R := d1[i] - 1
		L := i - R - 1
		R_idx := i + R + 1
		if L >= 0 && R_idx < n {
			E := getE(L, R_idx)
			created[L*26+int(s[R_idx]-'a')] += int32(E + 1)
			created[R_idx*26+int(s[L]-'a')] += int32(E + 1)
		}

		R2 := d2[i]
		L2 := i - R2
		R2_idx := i + 1 + R2
		if L2 >= 0 && R2_idx < n {
			E := getE(L2, R2_idx)
			created[L2*26+int(s[R2_idx]-'a')] += int32(E + 1)
			created[R2_idx*26+int(s[L2]-'a')] += int32(E + 1)
		}
	}

	compareStrings := func(i1 int, c1 byte, i2 int, c2 byte, s string) int {
		if i1 == i2 {
			if c1 < c2 {
				return -1
			}
			if c1 > c2 {
				return 1
			}
			return 0
		}
		if i1 < i2 {
			if c1 < s[i1] {
				return -1
			}
			if c1 > s[i1] {
				return 1
			}
			return 0
		} else {
			if s[i2] < c2 {
				return -1
			}
			if s[i2] > c2 {
				return 1
			}
			return 0
		}
	}

	maxScore := base
	bestI := -1
	var bestC byte = 0

	for i := 0; i < n; i++ {
		for c := byte('a'); c <= byte('z'); c++ {
			if c == s[i] {
				continue
			}
			score := base + int64(created[i*26+int(c-'a')]) - int64(C[i]-M[i])
			if score > maxScore {
				maxScore = score
				bestI = i
				bestC = c
			} else if score == maxScore {
				if bestI == -1 {
					if c < s[i] {
						bestI = i
						bestC = c
					}
				} else {
					if compareStrings(i, c, bestI, bestC, s) < 0 {
						bestI = i
						bestC = c
					}
				}
			}
		}
	}

	fmt.Println(maxScore)
	if bestI == -1 {
		fmt.Println(s)
	} else {
		out := []byte(s)
		out[bestI] = bestC
		fmt.Println(string(out))
	}
}