For problem statement at 2000-2999/2000-2099/2030-2039/2038/problemI.txt this is a correct solution, but verifier at 2000-2999/2000-2099/2030-2039/2038/verifierI.go ends with mismatch at token 1: expected "15" got "123"
exit status 1 can you fix the verifier? package main

import (
	"io"
	"os"
	"strconv"
)

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	readInt := func() int {
		for idx < len(data) && data[idx] <= ' ' {
			idx++
		}
		x := 0
		for idx < len(data) && data[idx] > ' ' {
			x = x*10 + int(data[idx]-'0')
			idx++
		}
		return x
	}

	n := readInt()
	m := readInt()

	bits := make([]byte, n*m)
	for i := 0; i < n; i++ {
		for idx < len(data) && data[idx] != '0' && data[idx] != '1' {
			idx++
		}
		base := i * m
		for j := 0; j < m; j++ {
			bits[base+j] = data[idx] - '0'
			idx++
		}
	}

	suff := make([]uint32, (m+1)*n)
	ordA := make([]int, n)
	ordB := make([]int, n)
	for i := 0; i < n; i++ {
		ordA[i] = i
	}

	for p := m - 1; p >= 0; p-- {
		count0 := 0
		for i := 0; i < n; i++ {
			row := ordA[i]
			if bits[row*m+p] == 0 {
				count0++
			}
		}
		z, o := 0, count0
		for i := 0; i < n; i++ {
			row := ordA[i]
			if bits[row*m+p] == 0 {
				ordB[z] = row
				z++
			} else {
				ordB[o] = row
				o++
			}
		}
		baseCur := p * n
		baseNext := (p + 1) * n
		prevRow := ordB[0]
		prevBit := bits[prevRow*m+p]
		prevNext := suff[baseNext+prevRow]
		var rank uint32
		suff[baseCur+prevRow] = 0
		for i := 1; i < n; i++ {
			row := ordB[i]
			b := bits[row*m+p]
			nx := suff[baseNext+row]
			if b != prevBit || nx != prevNext {
				rank++
				prevBit = b
				prevNext = nx
			}
			suff[baseCur+row] = rank
		}
		ordA, ordB = ordB, ordA
	}

	prePrev := make([]uint32, n)
	preCur := make([]uint32, n)
	for i := 0; i < n; i++ {
		ordA[i] = i
	}

	out := make([]byte, 0, m*8)

	bestRow := 0
	bestS := suff[0]
	for i := 1; i < n; i++ {
		if suff[i] > bestS {
			bestS = suff[i]
			bestRow = i
		}
	}
	out = strconv.AppendInt(out, int64(bestRow+1), 10)

	for p := 1; p < m; p++ {
		bpos := p - 1
		cur := 0
		for l := 0; l < n; {
			rv := prePrev[ordA[l]]
			r := l + 1
			for r < n && prePrev[ordA[r]] == rv {
				r++
			}
			for i := l; i < r; i++ {
				row := ordA[i]
				if bits[row*m+bpos] == 0 {
					ordB[cur] = row
					cur++
				}
			}
			for i := l; i < r; i++ {
				row := ordA[i]
				if bits[row*m+bpos] != 0 {
					ordB[cur] = row
					cur++
				}
			}
			l = r
		}

		prevRow := ordB[0]
		prevRank := prePrev[prevRow]
		prevBit := bits[prevRow*m+bpos]
		var rank uint32
		preCur[prevRow] = 0
		for i := 1; i < n; i++ {
			row := ordB[i]
			rv := prePrev[row]
			b := bits[row*m+bpos]
			if rv != prevRank || b != prevBit {
				rank++
				prevRank = rv
				prevBit = b
			}
			preCur[row] = rank
		}

		baseS := p * n
		bestRow = 0
		bestS = suff[baseS]
		bestP := preCur[0]
		for i := 1; i < n; i++ {
			sr := suff[baseS+i]
			pr := preCur[i]
			if sr > bestS || (sr == bestS && pr > bestP) {
				bestS = sr
				bestP = pr
				bestRow = i
			}
		}

		out = append(out, ' ')
		out = strconv.AppendInt(out, int64(bestRow+1), 10)

		prePrev, preCur = preCur, prePrev
		ordA, ordB = ordB, ordA
	}

	out = append(out, '\n')
	os.Stdout.Write(out)
}