For problem statement at 1000-1999/1700-1799/1770-1779/1773/problemD.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1770-1779/1773/verifierD.go ends with All 80 tests passed. can you fix the verifier? package main

import (
	"fmt"
	"io"
	"os"
)

var data []byte
var ptr int

func nextInt() int {
	for ptr < len(data) && data[ptr] <= ' ' {
		ptr++
	}
	v := 0
	for ptr < len(data) && data[ptr] > ' ' {
		v = v*10 + int(data[ptr]-'0')
		ptr++
	}
	return v
}

func nextBytes() []byte {
	for ptr < len(data) && data[ptr] <= ' ' {
		ptr++
	}
	start := ptr
	for ptr < len(data) && data[ptr] > ' ' {
		ptr++
	}
	return data[start:ptr]
}

func main() {
	data, _ = io.ReadAll(os.Stdin)
	n := nextInt()
	m := nextInt()

	rows := make([][]byte, n)
	empty := 0
	for i := 0; i < n; i++ {
		rows[i] = nextBytes()
		for _, c := range rows[i] {
			if c == '.' {
				empty++
			}
		}
	}

	if empty > 2000 {
		fmt.Print(1000000)
		return
	}

	idmap := make([]int, n*m)
	L, R := 0, 0
	for i := 0; i < n; i++ {
		base := i * m
		row := rows[i]
		for j, c := range row {
			if c != '.' {
				continue
			}
			if ((i + j) & 1) == 0 {
				L++
				idmap[base+j] = L
			} else {
				R++
				idmap[base+j] = -R
			}
		}
	}

	adj := make([][]int, L)
	for i := 0; i < n; i++ {
		base := i * m
		for j := 0; j < m; j++ {
			id := idmap[base+j]
			if id <= 0 {
				continue
			}
			u := id - 1
			if i > 0 {
				t := idmap[base-m+j]
				if t < 0 {
					adj[u] = append(adj[u], -t-1)
				}
			}
			if i+1 < n {
				t := idmap[base+m+j]
				if t < 0 {
					adj[u] = append(adj[u], -t-1)
				}
			}
			if j > 0 {
				t := idmap[base+j-1]
				if t < 0 {
					adj[u] = append(adj[u], -t-1)
				}
			}
			if j+1 < m {
				t := idmap[base+j+1]
				if t < 0 {
					adj[u] = append(adj[u], -t-1)
				}
			}
		}
	}

	pairU := make([]int, L)
	for i := range pairU {
		pairU[i] = -1
	}
	pairV := make([]int, R)
	for i := range pairV {
		pairV[i] = -1
	}
	dist := make([]int, L)
	queue := make([]int, L)
	const inf = int(1 << 30)

	bfs := func() bool {
		head, tail := 0, 0
		found := false
		for u := 0; u < L; u++ {
			if pairU[u] == -1 {
				dist[u] = 0
				queue[tail] = u
				tail++
			} else {
				dist[u] = inf
			}
		}
		for head < tail {
			u := queue[head]
			head++
			for _, v := range adj[u] {
				pu := pairV[v]
				if pu == -1 {
					found = true
				} else if dist[pu] == inf {
					dist[pu] = dist[u] + 1
					queue[tail] = pu
					tail++
				}
			}
		}
		return found
	}

	var dfs func(int) bool
	dfs = func(u int) bool {
		for _, v := range adj[u] {
			pu := pairV[v]
			if pu == -1 || (dist[pu] == dist[u]+1 && dfs(pu)) {
				pairU[u] = v
				pairV[v] = u
				return true
			}
		}
		dist[u] = inf
		return false
	}

	for bfs() {
		for u := 0; u < L; u++ {
			if pairU[u] == -1 {
				dfs(u)
			}
		}
	}

	V := L + R
	dir := make([][]int, V)
	for u := 0; u < L; u++ {
		mu := pairU[u]
		for _, v := range adj[u] {
			if v == mu {
				dir[u] = append(dir[u], L+v)
			} else {
				dir[L+v] = append(dir[L+v], u)
			}
		}
	}

	vis := make([]int, V)
	q := make([]int, V)
	stamp := 0
	var good int64

	for s := 0; s < L; s++ {
		stamp++
		head, tail := 0, 0
		q[tail] = s
		tail++
		vis[s] = stamp
		for head < tail {
			x := q[head]
			head++
			if x >= L {
				good++
			}
			for _, y := range dir[x] {
				if vis[y] != stamp {
					vis[y] = stamp
					q[tail] = y
					tail++
				}
			}
		}
	}

	same := int64(L)*(int64(L)-1)/2 + int64(R)*(int64(R)-1)/2
	ans := same + int64(L)*int64(R) - good
	if ans > 1000000 {
		ans = 1000000
	}
	fmt.Print(ans)
}