For problem statement at 0-999/300-399/370-379/370/problemD.txt this is a correct solution, but verifier at 0-999/300-399/370-379/370/verifierD.go ends with case 26 mismatch
expected:
.+w+
.+.+
.ww+
....
....

got:
++w.
+.+.
+ww.
....
....
exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"io"
	"os"
)

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	readInt := func() int {
		for idx < len(data) && data[idx] <= 32 {
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] > 32 {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return val
	}

	readToken := func() []byte {
		for idx < len(data) && data[idx] <= 32 {
			idx++
		}
		start := idx
		for idx < len(data) && data[idx] > 32 {
			idx++
		}
		return data[start:idx]
	}

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

	grid := make([][]byte, n)
	rmin, rmax := n, -1
	cmin, cmax := m, -1

	for i := 0; i < n; i++ {
		row := readToken()
		grid[i] = row
		for j, b := range row {
			if b == 'w' {
				if i < rmin {
					rmin = i
				}
				if i > rmax {
					rmax = i
				}
				if j < cmin {
					cmin = j
				}
				if j > cmax {
					cmax = j
				}
			}
		}
	}

	wr := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer wr.Flush()

	printNo := func() {
		wr.WriteString("-1\n")
	}

	h := rmax - rmin + 1
	w := cmax - cmin + 1

	valid := true
	hasCmin, hasCmax := false, false
	hasRmin, hasRmax := false, false

	for i := 0; i < n && valid; i++ {
		for j, b := range grid[i] {
			if b != 'w' {
				continue
			}
			if !(i == rmin || i == rmax || j == cmin || j == cmax) {
				valid = false
				break
			}
			if h > w && i > rmin && i < rmax {
				if j == cmin {
					hasCmin = true
				}
				if j == cmax {
					hasCmax = true
				}
			}
			if w > h && j > cmin && j < cmax {
				if i == rmin {
					hasRmin = true
				}
				if i == rmax {
					hasRmax = true
				}
			}
		}
	}

	if !valid {
		printNo()
		return
	}

	top, left, d := 0, 0, 0

	if h == w {
		top = rmin
		left = cmin
		d = h
	} else if h > w {
		d = h
		llo := cmax - d + 1
		if llo < 0 {
			llo = 0
		}
		lhi := cmin
		if m-d < lhi {
			lhi = m - d
		}
		if llo > lhi {
			printNo()
			return
		}

		cnt := 0
		if hasCmin {
			cnt++
		}
		if cmax != cmin && hasCmax {
			cnt++
		}
		if cnt == 2 {
			printNo()
			return
		}
		if cnt == 0 {
			left = llo
		} else {
			x := cmin
			if !hasCmin {
				x = cmax
			}
			ok := false
			cand1 := x
			if cand1 >= llo && cand1 <= lhi {
				left = cand1
				ok = true
			}
			cand2 := x - d + 1
			if !ok && cand2 >= llo && cand2 <= lhi {
				left = cand2
				ok = true
			}
			if !ok {
				printNo()
				return
			}
		}
		top = rmin
	} else {
		d = w
		tlo := rmax - d + 1
		if tlo < 0 {
			tlo = 0
		}
		thi := rmin
		if n-d < thi {
			thi = n - d
		}
		if tlo > thi {
			printNo()
			return
		}

		cnt := 0
		if hasRmin {
			cnt++
		}
		if rmax != rmin && hasRmax {
			cnt++
		}
		if cnt == 2 {
			printNo()
			return
		}
		if cnt == 0 {
			top = tlo
		} else {
			x := rmin
			if !hasRmin {
				x = rmax
			}
			ok := false
			cand1 := x
			if cand1 >= tlo && cand1 <= thi {
				top = cand1
				ok = true
			}
			cand2 := x - d + 1
			if !ok && cand2 >= tlo && cand2 <= thi {
				top = cand2
				ok = true
			}
			if !ok {
				printNo()
				return
			}
		}
		left = cmin
	}

	bottom := top + d - 1
	right := left + d - 1

	if top < 0 || left < 0 || bottom >= n || right >= m {
		printNo()
		return
	}

	for i := 0; i < n && valid; i++ {
		for j, b := range grid[i] {
			if b != 'w' {
				continue
			}
			if !(i >= top && i <= bottom && j >= left && j <= right && (i == top || i == bottom || j == left || j == right)) {
				valid = false
				break
			}
		}
	}

	if !valid {
		printNo()
		return
	}

	for j := left; j <= right; j++ {
		if grid[top][j] == '.' {
			grid[top][j] = '+'
		}
		if bottom != top && grid[bottom][j] == '.' {
			grid[bottom][j] = '+'
		}
	}
	for i := top + 1; i < bottom; i++ {
		if grid[i][left] == '.' {
			grid[i][left] = '+'
		}
		if right != left && grid[i][right] == '.' {
			grid[i][right] = '+'
		}
	}

	for i := 0; i < n; i++ {
		wr.Write(grid[i])
		wr.WriteByte('\n')
	}
}