For problem statement at 2000-2999/2000-2099/2060-2069/2064/problemE.txt this is a correct solution, but verifier at 2000-2999/2000-2099/2060-2069/2064/verifierE.go ends with reference runtime error on test 1 (sample): exit status 2
input:
4
1
1
1
1
5
3 4 1 2
1 1 1 1 1
5
4 2 3 1 5
2 1 4 1 5
40
29 15 20 35 37 31 27 1 32 36 38 25 22 8 16 7 3 28 11 12 23 4 14 9 39 13 10 30 6 2 24 17 19 5 34 18 33 26 40 21
3 1 2 2 1 2 3 1 1 1 1 2 1 3 1 1 3 1 1 1 2 2 1 3 3 3 2 3 2 2 2 2 1 3 2 1 1 2 2 2
output:
1
panic: runtime error: index out of range [5] with length 2

goroutine 1 [running]:
main.solveCase(0x1, {0x4000098050?, 0x40000a0f10?, 0x1?}, {0x4000098058, 0x1, 0x400003a668?})
	/home/ubuntu/codeforces/2000-2999/2000-2099/2060-2069/2064/2064E.go:140 +0x2e0
main.main()
	/home/ubuntu/codeforces/2000-2999/2000-2099/2060-2069/2064/2064E.go:183 +0x1d0
exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

type Scanner struct {
	reader *bufio.Reader
}

func (s *Scanner) NextInt() int {
	var res int
	var c byte
	for {
		c, _ = s.reader.ReadByte()
		if c > ' ' {
			break
		}
		if c == 0 {
			return 0
		}
	}
	for {
		res = res*10 + int(c-'0')
		c, _ = s.reader.ReadByte()
		if c <= ' ' {
			break
		}
	}
	return res
}

func find(i int, parent []int) int {
	root := i
	for parent[root] != root {
		root = parent[root]
	}
	curr := i
	for parent[curr] != root {
		nxt := parent[curr]
		parent[curr] = root
		curr = nxt
	}
	return root
}

func unite(i, j int, parent, size []int) {
	rootI := find(i, parent)
	rootJ := find(j, parent)
	if rootI != rootJ {
		parent[rootI] = rootJ
		size[rootJ] += size[rootI]
	}
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 65536)
	scanner := &Scanner{reader: reader}
	writer := bufio.NewWriterSize(os.Stdout, 65536)
	defer writer.Flush()

	t := scanner.NextInt()
	if t == 0 {
		return
	}

	for i := 0; i < t; i++ {
		n := scanner.NextInt()

		p := make([]int, n+1)
		x := make([]int, n+1)
		for j := 1; j <= n; j++ {
			p[j] = scanner.NextInt()
			x[p[j]] = j
		}

		cArr := make([]int, n+1)
		for j := 1; j <= n; j++ {
			cArr[j] = scanner.NextInt()
		}

		parent := make([]int, n+1)
		size := make([]int, n+1)
		for j := 0; j <= n; j++ {
			parent[j] = j
			size[j] = 1
		}

		for j := 1; j < n; j++ {
			if cArr[j] == cArr[j+1] {
				unite(j, j+1, parent, size)
			}
		}

		L := make([]int, n+2)
		R := make([]int, n+2)
		for j := 1; j <= n; j++ {
			L[j] = j - 1
			R[j] = j + 1
		}
		L[0] = 0
		R[n+1] = n + 1

		var ans int64 = 1
		var MOD int64 = 998244353

		for k := 1; k <= n; k++ {
			u := x[k]
			root := find(u, parent)
			currentSize := int64(size[root])
			ans = (ans * currentSize) % MOD

			size[root]--

			prev := L[u]
			next := R[u]

			if prev >= 1 {
				R[prev] = next
			}
			if next <= n {
				L[next] = prev
			}

			if prev >= 1 && next <= n && cArr[prev] == cArr[next] {
				unite(prev, next, parent, size)
			}
		}

		fmt.Fprintln(writer, ans)
	}
}
```