For problem statement at 1000-1999/1700-1799/1760-1769/1763/problemF.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1760-1769/1763/verifierF.go ends with All tests passed can you fix the verifier? package main

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

type Frame struct {
	u   int
	idx int
}

type Block struct {
	start int
	end   int
	edges int
}

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

	n := nextInt()
	m := nextInt()

	uEdge := make([]int, m)
	vEdge := make([]int, m)
	adj := make([][]int, n+1)

	for i := 0; i < m; i++ {
		u := nextInt()
		v := nextInt()
		uEdge[i] = u
		vEdge[i] = v
		adj[u] = append(adj[u], i)
		adj[v] = append(adj[v], i)
	}

	tin := make([]int, n+1)
	low := make([]int, n+1)
	parent := make([]int, n+1)
	parentEdge := make([]int, n+1)
	for i := 1; i <= n; i++ {
		parentEdge[i] = -1
	}

	mark := make([]int, n+1)
	stamp := 0
	allVerts := make([]int, 0, n)
	blocks := make([]Block, 0)
	bridgeU := make([]int, 0)
	bridgeV := make([]int, 0)
	edgeStack := make([]int, 0, m)
	frames := make([]Frame, 0, n)
	timer := 0

	processComp := func(stopEdge int) {
		stamp++
		start := len(allVerts)
		edgeCount := 0
		lastE := -1
		for len(edgeStack) > 0 {
			e := edgeStack[len(edgeStack)-1]
			edgeStack = edgeStack[:len(edgeStack)-1]
			lastE = e
			edgeCount++
			a := uEdge[e]
			b := vEdge[e]
			if mark[a] != stamp {
				mark[a] = stamp
				allVerts = append(allVerts, a)
			}
			if mark[b] != stamp {
				mark[b] = stamp
				allVerts = append(allVerts, b)
			}
			if e == stopEdge {
				break
			}
		}
		if edgeCount == 1 {
			bridgeU = append(bridgeU, uEdge[lastE])
			bridgeV = append(bridgeV, vEdge[lastE])
			allVerts = allVerts[:start]
		} else if edgeCount > 1 {
			blocks = append(blocks, Block{start: start, end: len(allVerts), edges: edgeCount})
		}
	}

	for s := 1; s <= n; s++ {
		if tin[s] != 0 {
			continue
		}
		timer++
		tin[s] = timer
		low[s] = timer
		parent[s] = 0
		parentEdge[s] = -1
		frames = append(frames, Frame{u: s, idx: 0})

		for len(frames) > 0 {
			top := len(frames) - 1
			u := frames[top].u
			if frames[top].idx < len(adj[u]) {
				eid := adj[u][frames[top].idx]
				frames[top].idx++
				v := uEdge[eid]
				if v == u {
					v = vEdge[eid]
				}
				if tin[v] == 0 {
					edgeStack = append(edgeStack, eid)
					parent[v] = u
					parentEdge[v] = eid
					timer++
					tin[v] = timer
					low[v] = timer
					frames = append(frames, Frame{u: v, idx: 0})
				} else if eid != parentEdge[u] && tin[v] < tin[u] {
					edgeStack = append(edgeStack, eid)
					if low[u] > tin[v] {
						low[u] = tin[v]
					}
				}
			} else {
				frames = frames[:top]
				if parent[u] != 0 {
					pu := parent[u]
					if low[pu] > low[u] {
						low[pu] = low[u]
					}
					if low[u] >= tin[pu] {
						processComp(parentEdge[u])
					}
				}
			}
		}

		if len(edgeStack) > 0 {
			processComp(-1)
		}
	}

	numBlocks := len(blocks)
	totalNodes := n + numBlocks

	tree := make([][]int, totalNodes+1)
	weight := make([]int64, totalNodes+1)

	for i, b := range blocks {
		id := n + i + 1
		weight[id] = int64(b.edges)
		for j := b.start; j < b.end; j++ {
			v := allVerts[j]
			tree[id] = append(tree[id], v)
			tree[v] = append(tree[v], id)
		}
	}

	for i := 0; i < len(bridgeU); i++ {
		u := bridgeU[i]
		v := bridgeV[i]
		tree[u] = append(tree[u], v)
		tree[v] = append(tree[v], u)
	}

	log := 1
	for (1 << log) <= totalNodes {
		log++
	}

	up := make([][]int, log)
	for i := 0; i < log; i++ {
		up[i] = make([]int, totalNodes+1)
	}
	depth := make([]int, totalNodes+1)
	pref := make([]int64, totalNodes+1)
	vis := make([]bool, totalNodes+1)

	stack := make([]int, 0, totalNodes)
	stack = append(stack, 1)
	vis[1] = true
	up[0][1] = 1
	pref[1] = weight[1]

	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		for _, v := range tree[u] {
			if vis[v] {
				continue
			}
			vis[v] = true
			up[0][v] = u
			depth[v] = depth[u] + 1
			pref[v] = pref[u] + weight[v]
			stack = append(stack, v)
		}
	}

	for k := 1; k < log; k++ {
		prev := up[k-1]
		cur := up[k]
		for v := 1; v <= totalNodes; v++ {
			cur[v] = prev[prev[v]]
		}
	}

	lca := func(a, b int) int {
		u, v := a, b
		if depth[u] < depth[v] {
			u, v = v, u
		}
		diff := depth[u] - depth[v]
		bit := 0
		for diff > 0 {
			if diff&1 == 1 {
				u = up[bit][u]
			}
			diff >>= 1
			bit++
		}
		if u == v {
			return u
		}
		for k := log - 1; k >= 0; k-- {
			if up[k][u] != up[k][v] {
				u = up[k][u]
				v = up[k][v]
			}
		}
		return up[0][u]
	}

	q := nextInt()
	out := make([]byte, 0, q*8)
	for i := 0; i < q; i++ {
		a := nextInt()
		b := nextInt()
		l := lca(a, b)
		ans := pref[a] + pref[b] - 2*pref[l] + weight[l]
		out = strconv.AppendInt(out, ans, 10)
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}