For problem statement at 1000-1999/1200-1299/1210-1219/1218/problemH.txt this is a correct solution, but verifier at 1000-1999/1200-1299/1210-1219/1218/verifierH.go ends with all tests passed can you fix the verifier? ```go
package main

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

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] > ' ' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func (fs *FastScanner) NextInt64() int64 {
	for fs.idx < fs.n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	var val int64
	for fs.idx < fs.n && fs.data[fs.idx] > ' ' {
		val = val*10 + int64(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func lowerBound(a []int, x int) int {
	l, r := 0, len(a)
	for l < r {
		m := int(uint(l+r) >> 1)
		if a[m] < x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func upperBound64(a []int, x int64) int {
	l, r := 0, len(a)
	for l < r {
		m := int(uint(l+r) >> 1)
		if int64(a[m]) <= x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

type Frame struct {
	u   int
	idx int
}

func main() {
	fs := NewFastScanner()

	n := fs.NextInt()
	a := make([]int, n+1)
	indeg := make([]int, n+1)

	for i := 1; i <= n; i++ {
		v := fs.NextInt()
		a[i] = v
		indeg[v]++
	}

	rev := make([][]int, n+1)
	for i := 1; i <= n; i++ {
		rev[i] = make([]int, indeg[i])
	}
	ptr := make([]int, n+1)
	for i := 1; i <= n; i++ {
		v := a[i]
		rev[v][ptr[v]] = i
		ptr[v]++
	}

	queue := make([]int, n)
	head, tail := 0, 0
	for i := 1; i <= n; i++ {
		if indeg[i] == 0 {
			queue[tail] = i
			tail++
		}
	}
	for head < tail {
		u := queue[head]
		head++
		v := a[u]
		indeg[v]--
		if indeg[v] == 0 {
			queue[tail] = v
			tail++
		}
	}

	isCycle := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		if indeg[i] > 0 {
			isCycle[i] = true
		}
	}

	visitedCycle := make([]bool, n+1)
	comp := make([]int, n+1)
	dep := make([]int, n+1)
	rootPos := make([]int, n+1)
	roots := make([]int, 0)
	compLen := make([]int, 0)
	compResidues := make([][][]int, 0)

	head, tail = 0, 0
	for i := 1; i <= n; i++ {
		if isCycle[i] && !visitedCycle[i] {
			cycle := make([]int, 0)
			u := i
			for !visitedCycle[u] {
				visitedCycle[u] = true
				cycle = append(cycle, u)
				u = a[u]
			}
			cid := len(compLen)
			c := len(cycle)
			compLen = append(compLen, c)
			res := make([][]int, c)
			for p, u := range cycle {
				comp[u] = cid
				rootPos[u] = p
				r := (c - p) % c
				res[r] = append(res[r], 0)
				roots = append(roots, u)
				queue[tail] = u
				tail++
			}
			compResidues = append(compResidues, res)
		}
	}

	maxDepth := 0
	for head < tail {
		u := queue[head]
		head++
		for _, v := range rev[u] {
			if isCycle[v] {
				continue
			}
			comp[v] = comp[u]
			dep[v] = dep[u] + 1
			if dep[v] > maxDepth {
				maxDepth = dep[v]
			}
			rootPos[v] = rootPos[u]
			cid := comp[v]
			c := compLen[cid]
			r := dep[v] - rootPos[v]
			r %= c
			if r < 0 {
				r += c
			}
			compResidues[cid][r] = append(compResidues[cid][r], dep[v])
			queue[tail] = v
			tail++
		}
	}

	tin := make([]int, n+1)
	tout := make([]int, n+1)
	depthBins := make([][]int, maxDepth+1)
	timer := 0
	stack := make([]Frame, 0)

	for _, r := range roots {
		stack = stack[:0]
		stack = append(stack, Frame{u: r, idx: -1})
		for len(stack) > 0 {
			top := &stack[len(stack)-1]
			u := top.u
			if top.idx == -1 {
				timer++
				tin[u] = timer
				depthBins[dep[u]] = append(depthBins[dep[u]], timer)
				top.idx = 0
			}
			if top.idx < len(rev[u]) {
				v := rev[u][top.idx]
				top.idx++
				if isCycle[v] {
					continue
				}
				stack = append(stack, Frame{u: v, idx: -1})
			} else {
				tout[u] = timer
				stack = stack[:len(stack)-1]
			}
		}
	}

	q := fs.NextInt()
	out := make([]byte, 0, q*8)

	for i := 0; i < q; i++ {
		m := fs.NextInt64()
		y := fs.NextInt()
		ans := 0

		if !isCycle[y] {
			if int64(dep[y])+m <= int64(maxDepth) {
				target := dep[y] + int(m)
				list := depthBins[target]
				l := lowerBound(list, tin[y])
				r := lowerBound(list, tout[y]+1)
				ans = r - l
			}
		} else {
			cid := comp[y]
			c := compLen[cid]
			py := rootPos[y]
			r := int((m%int64(c) - int64(py) + int64(c)) % int64(c))
			ans = upperBound64(compResidues[cid][r], m)
		}

		out = strconv.AppendInt(out, int64(ans), 10)
		out = append(out, '\n')
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out)
	w.Flush()
}
```