For problem statement at 0-999/600-699/620-629/620/problemE.txt this is a correct solution, but verifier at 0-999/600-699/620-629/620/verifierE.go ends with All 102 tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

var (
	in     []int
	out    []int
	timer  int
	adj    [][]int
	colors []int
	flat   []int
)

func dfs(root int) {
	type frame struct {
		v, p int
		idx  int
	}
	stack := []frame{{root, 0, 0}}
	for len(stack) > 0 {
		f := &stack[len(stack)-1]
		if f.idx == 0 {
			in[f.v] = timer
			flat[timer] = colors[f.v]
			timer++
		}
		if f.idx < len(adj[f.v]) {
			u := adj[f.v][f.idx]
			f.idx++
			if u != f.p {
				stack = append(stack, frame{u, f.v, 0})
			}
		} else {
			out[f.v] = timer - 1
			stack = stack[:len(stack)-1]
		}
	}
}

type SegmentTree struct {
	tree []uint64
	lazy []int
	n    int
}

func NewSegmentTree(arr []int) *SegmentTree {
	n := len(arr)
	st := &SegmentTree{
		tree: make([]uint64, 4*n),
		lazy: make([]int, 4*n),
		n:    n,
	}
	for i := range st.lazy {
		st.lazy[i] = -1
	}
	st.build(1, 0, n-1, arr)
	return st
}

func (st *SegmentTree) build(node, l, r int, arr []int) {
	if l == r {
		st.tree[node] = uint64(1) << arr[l]
		return
	}
	mid := (l + r) / 2
	st.build(2*node, l, mid, arr)
	st.build(2*node+1, mid+1, r, arr)
	st.tree[node] = st.tree[2*node] | st.tree[2*node+1]
}

func (st *SegmentTree) push(node, l, r int) {
	if st.lazy[node] != -1 {
		st.tree[node] = uint64(1) << st.lazy[node]
		if l != r {
			st.lazy[2*node] = st.lazy[node]
			st.lazy[2*node+1] = st.lazy[node]
		}
		st.lazy[node] = -1
	}
}

func (st *SegmentTree) Update(node, l, r, ql, qr, c int) {
	st.push(node, l, r)
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		st.lazy[node] = c
		st.push(node, l, r)
		return
	}
	mid := (l + r) / 2
	st.Update(2*node, l, mid, ql, qr, c)
	st.Update(2*node+1, mid+1, r, ql, qr, c)
	st.tree[node] = st.tree[2*node] | st.tree[2*node+1]
}

func (st *SegmentTree) Query(node, l, r, ql, qr int) uint64 {
	st.push(node, l, r)
	if ql > r || qr < l {
		return 0
	}
	if ql <= l && r <= qr {
		return st.tree[node]
	}
	mid := (l + r) / 2
	return st.Query(2*node, l, mid, ql, qr) | st.Query(2*node+1, mid+1, r, ql, qr)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n, m int
	fmt.Fscan(reader, &n, &m)

	colors = make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(reader, &colors[i])
	}

	adj = make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		var x, y int
		fmt.Fscan(reader, &x, &y)
		adj[x] = append(adj[x], y)
		adj[y] = append(adj[y], x)
	}

	in = make([]int, n+1)
	out = make([]int, n+1)
	flat = make([]int, n)
	timer = 0
	dfs(1)

	st := NewSegmentTree(flat)

	for i := 0; i < m; i++ {
		var t int
		fmt.Fscan(reader, &t)
		if t == 1 {
			var v, c int
			fmt.Fscan(reader, &v, &c)
			st.Update(1, 0, n-1, in[v], out[v], c)
		} else {
			var v int
			fmt.Fscan(reader, &v)
			result := st.Query(1, 0, n-1, in[v], out[v])
			fmt.Fprintln(writer, bits.OnesCount64(result))
		}
	}
}
```