For problem statement at 0-999/600-699/630-639/633/problemG.txt this is a correct solution, but verifier at 0-999/600-699/630-639/633/verifierG.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"io"
	"math/bits"
	"os"
	"strconv"
)

const MaxWords = 16

type FastScanner struct {
	data []byte
	idx  int
}

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

var (
	m        int
	W        int
	lastMask uint64
	seg      [][MaxWords]uint64
	lazy     []int
	flat     []int
	primeMask [MaxWords]uint64
)

func rotateArr(a *[MaxWords]uint64, d int) {
	if m == 1 {
		return
	}
	d %= m
	if d == 0 {
		return
	}
	var left, right [MaxWords]uint64

	lws := d >> 6
	lbs := uint(d & 63)
	if lbs == 0 {
		for i := W - 1; i >= 0; i-- {
			j := i - lws
			if j >= 0 {
				left[i] = a[j]
			}
		}
	} else {
		sh := 64 - lbs
		for i := W - 1; i >= 0; i-- {
			j := i - lws
			if j >= 0 {
				v := a[j] << lbs
				if j > 0 {
					v |= a[j-1] >> sh
				}
				left[i] = v
			}
		}
	}

	r := m - d
	rws := r >> 6
	rbs := uint(r & 63)
	if rbs == 0 {
		for i := 0; i < W; i++ {
			j := i + rws
			if j < W {
				right[i] = a[j]
			}
		}
	} else {
		sh := 64 - rbs
		for i := 0; i < W; i++ {
			j := i + rws
			if j < W {
				v := a[j] >> rbs
				if j+1 < W {
					v |= a[j+1] << sh
				}
				right[i] = v
			}
		}
	}

	for i := 0; i < W; i++ {
		a[i] = left[i] | right[i]
	}
	a[W-1] &= lastMask
}

func pull(idx int) {
	l := idx << 1
	r := l | 1
	for i := 0; i < W; i++ {
		seg[idx][i] = seg[l][i] | seg[r][i]
	}
}

func push(idx int) {
	d := lazy[idx]
	if d == 0 {
		return
	}
	l := idx << 1
	r := l | 1

	rotateArr(&seg[l], d)
	rotateArr(&seg[r], d)

	lazy[l] += d
	if lazy[l] >= m {
		lazy[l] -= m
	}
	lazy[r] += d
	if lazy[r] >= m {
		lazy[r] -= m
	}

	lazy[idx] = 0
}

func build(idx, l, r int) {
	if l == r {
		res := flat[l]
		seg[idx][res>>6] = uint64(1) << uint(res&63)
		return
	}
	mid := (l + r) >> 1
	build(idx<<1, l, mid)
	build(idx<<1|1, mid+1, r)
	pull(idx)
}

func update(idx, l, r, ql, qr, d int) {
	if ql <= l && r <= qr {
		rotateArr(&seg[idx], d)
		lazy[idx] += d
		if lazy[idx] >= m {
			lazy[idx] -= m
		}
		return
	}
	if lazy[idx] != 0 {
		push(idx)
	}
	mid := (l + r) >> 1
	if ql <= mid {
		update(idx<<1, l, mid, ql, qr, d)
	}
	if qr > mid {
		update(idx<<1|1, mid+1, r, ql, qr, d)
	}
	pull(idx)
}

func query(idx, l, r, ql, qr int, acc *[MaxWords]uint64) {
	if ql <= l && r <= qr {
		for i := 0; i < W; i++ {
			acc[i] |= seg[idx][i]
		}
		return
	}
	if lazy[idx] != 0 {
		push(idx)
	}
	mid := (l + r) >> 1
	if ql <= mid {
		query(idx<<1, l, mid, ql, qr, acc)
	}
	if qr > mid {
		query(idx<<1|1, mid+1, r, ql, qr, acc)
	}
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	n := fs.NextInt()
	m = fs.NextInt()

	W = (m + 63) >> 6
	rem := m & 63
	if rem == 0 {
		lastMask = ^uint64(0)
	} else {
		lastMask = (uint64(1) << uint(rem)) - 1
	}

	val := make([]int, n+1)
	if m == 1 {
		for i := 1; i <= n; i++ {
			_ = fs.NextInt()
			val[i] = 0
		}
	} else {
		for i := 1; i <= n; i++ {
			val[i] = fs.NextInt() % m
		}
	}

	head := make([]int, n+1)
	for i := range head {
		head[i] = -1
	}
	to := make([]int, 2*(n-1))
	next := make([]int, 2*(n-1))
	ei := 0
	for i := 0; i < n-1; i++ {
		u := fs.NextInt()
		v := fs.NextInt()

		to[ei] = v
		next[ei] = head[u]
		head[u] = ei
		ei++

		to[ei] = u
		next[ei] = head[v]
		head[v] = ei
		ei++
	}

	parent := make([]int, n+1)
	order := make([]int, 0, n)
	stack := make([]int, 0, n)
	stack = append(stack, 1)
	parent[1] = 0

	for len(stack) > 0 {
		v := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, v)
		for e := head[v]; e != -1; e = next[e] {
			u := to[e]
			if u == parent[v] {
				continue
			}
			parent[u] = v
			stack = append(stack, u)
		}
	}

	tin := make([]int, n+1)
	sz := make([]int, n+1)
	for i := 1; i <= n; i++ {
		sz[i] = 1
	}
	flat = make([]int, n)
	for i, v := range order {
		tin[v] = i
		flat[i] = val[v]
	}
	for i := len(order) - 1; i > 0; i-- {
		v := order[i]
		sz[parent[v]] += sz[v]
	}

	if m > 2 {
		isPrime := make([]bool, m)
		for i := 2; i < m; i++ {
			isPrime[i] = true
		}
		for i := 2; i*i < m; i++ {
			if isPrime[i] {
				for j := i * i; j < m; j += i {
					isPrime[j] = false
				}
			}
		}
		for i := 2; i < m; i++ {
			if isPrime[i] {
				primeMask[i>>6] |= uint64(1) << uint(i&63)
			}
		}
	}

	seg = make([][MaxWords]uint64, 4*n+5)
	lazy = make([]int, 4*n+5)
	build(1, 0, n-1)

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

	for ; q > 0; q-- {
		typ := fs.NextInt()
		if typ == 1 {
			v := fs.NextInt()
			x := fs.NextInt()
			if m > 1 {
				d := x % m
				if d != 0 {
					l := tin[v]
					r := l + sz[v] - 1
					update(1, 0, n-1, l, r, d)
				}
			}
		} else {
			v := fs.NextInt()
			l := tin[v]
			r := l + sz[v] - 1
			var acc [MaxWords]uint64
			query(1, 0, n-1, l, r, &acc)
			cnt := 0
			for i := 0; i < W; i++ {
				cnt += bits.OnesCount64(acc[i] & primeMask[i])
			}
			out = strconv.AppendInt(out, int64(cnt), 10)
			out = append(out, '\n')
		}
	}

	_, _ = os.Stdout.Write(out)
}
```