For problem statement at 2000-2999/2000-2099/2090-2099/2097/problemB.txt this is a correct solution, but verifier at 2000-2999/2000-2099/2090-2099/2097/verifierB.go ends with All 120 tests passed. can you fix the verifier? package main

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

const MOD int64 = 1000000007

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0
	nextInt := func() int {
		for p < len(data) && (data[p] < '0' || data[p] > '9') && data[p] != '-' {
			p++
		}
		sign := 1
		if data[p] == '-' {
			sign = -1
			p++
		}
		val := 0
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			val = val*10 + int(data[p]-'0')
			p++
		}
		return sign * val
	}

	t := nextInt()
	out := make([]byte, 0, t*3)

	abs := func(x int) int {
		if x < 0 {
			return -x
		}
		return x
	}

	for ; t > 0; t-- {
		n := nextInt()
		m := nextInt()
		k := nextInt()

		nm := n * m
		xs := make([]int, k+1)
		ys := make([]int, k+1)
		odd := make([]bool, nm)

		for i := 0; i <= k; i++ {
			x := nextInt() - 1
			y := nextInt() - 1
			xs[i] = x
			ys[i] = y
			odd[x*m+y] = true
		}

		c1 := make([]int, k)
		c2 := make([]int, k)
		sz := make([]int, k)
		vid := make([]int, nm)
		vc := 0
		totalInc := 0
		ok := true

		getV := func(id int) int {
			if vid[id] == 0 {
				vc++
				vid[id] = vc
			}
			return vid[id] - 1
		}

		for i := 0; i < k; i++ {
			x1, y1 := xs[i], ys[i]
			x2, y2 := xs[i+1], ys[i+1]
			adx := abs(x2 - x1)
			ady := abs(y2 - y1)

			if adx == 2 && y1 == y2 {
				id := ((x1 + x2) / 2 * m) + y1
				if !odd[id] {
					c1[i] = getV(id)
					c2[i] = -1
					sz[i] = 1
					totalInc++
				}
			} else if x1 == x2 && ady == 2 {
				id := x1*m + (y1+y2)/2
				if !odd[id] {
					c1[i] = getV(id)
					c2[i] = -1
					sz[i] = 1
					totalInc++
				}
			} else if adx == 1 && ady == 1 {
				cnt := 0
				id1 := x1*m + y2
				if !odd[id1] {
					c1[i] = getV(id1)
					cnt++
					totalInc++
				}
				id2 := x2*m + y1
				if !odd[id2] {
					v := getV(id2)
					if cnt == 0 {
						c1[i] = v
					} else {
						c2[i] = v
					}
					cnt++
					totalInc++
				}
				sz[i] = cnt
				if cnt < 2 {
					c2[i] = -1
				}
			} else {
				sz[i] = 0
				c2[i] = -1
			}

			if sz[i] == 0 {
				ok = false
			}
		}

		if !ok {
			out = strconv.AppendInt(out, 0, 10)
			out = append(out, '\n')
			continue
		}

		head := make([]int, vc)
		for i := 0; i < vc; i++ {
			head[i] = -1
		}
		to := make([]int, totalInc)
		next := make([]int, totalInc)
		ptr := 0

		add := func(v, idx int) {
			to[ptr] = idx
			next[ptr] = head[v]
			head[v] = ptr
			ptr++
		}

		for i := 0; i < k; i++ {
			if sz[i] >= 1 {
				add(c1[i], i)
			}
			if sz[i] == 2 {
				add(c2[i], i)
			}
		}

		queue := make([]int, 0)
		for i := 0; i < k; i++ {
			if sz[i] == 1 {
				queue = append(queue, i)
			}
		}

		occupied := make([]bool, vc)

		for qh := 0; qh < len(queue) && ok; qh++ {
			i := queue[qh]
			if sz[i] != 1 {
				continue
			}
			v := c1[i]
			sz[i] = 0

			if occupied[v] {
				ok = false
				break
			}
			occupied[v] = true

			for e := head[v]; e != -1; e = next[e] {
				j := to[e]
				if sz[j] == 0 {
					continue
				}
				if c1[j] == v {
					if sz[j] == 1 {
						ok = false
						break
					}
					c1[j] = c2[j]
					c2[j] = -1
					sz[j] = 1
					queue = append(queue, j)
				} else if sz[j] == 2 && c2[j] == v {
					c2[j] = -1
					sz[j] = 1
					queue = append(queue, j)
				}
			}
		}

		if !ok {
			out = strconv.AppendInt(out, 0, 10)
			out = append(out, '\n')
			continue
		}

		visV := make([]bool, vc)
		visE := make([]bool, k)
		stack := make([]int, 0)
		ans := int64(1)

		for i := 0; i < k && ok; i++ {
			if sz[i] != 2 || visE[i] {
				continue
			}

			compV, compE := 0, 1
			visE[i] = true
			stack = stack[:0]
			stack = append(stack, c1[i], c2[i])

			for len(stack) > 0 {
				v := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				if visV[v] {
					continue
				}
				visV[v] = true
				compV++

				for e := head[v]; e != -1; e = next[e] {
					j := to[e]
					if sz[j] != 2 {
						continue
					}
					if c1[j] != v && c2[j] != v {
						continue
					}
					if !visE[j] {
						visE[j] = true
						compE++
						stack = append(stack, c1[j], c2[j])
					}
				}
			}

			if compE > compV {
				ok = false
			} else if compE == compV-1 {
				ans = ans * int64(compV) % MOD
			} else if compE == compV {
				ans = ans * 2 % MOD
			} else {
				ok = false
			}
		}

		if !ok {
			out = strconv.AppendInt(out, 0, 10)
		} else {
			out = strconv.AppendInt(out, ans, 10)
		}
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}