For problem statement at 1000-1999/1600-1699/1620-1629/1628/problemE.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1620-1629/1628/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

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

var buf []byte
var pos int

func nextInt() int {
	for pos < len(buf) && (buf[pos] < '0' || buf[pos] > '9') {
		pos++
	}
	if pos >= len(buf) {
		return 0
	}
	res := 0
	for pos < len(buf) && buf[pos] >= '0' && buf[pos] <= '9' {
		res = res*10 + int(buf[pos]-'0')
		pos++
	}
	return res
}

type Edge struct {
	u, v, w int
}

type Node struct {
	lca_val int
	lca_all int
	lazy    int8
}

func main() {
	buf, _ = io.ReadAll(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	n := nextInt()
	q := nextInt()

	edges := make([]Edge, n-1)
	for i := 0; i < n-1; i++ {
		edges[i].u = nextInt()
		edges[i].v = nextInt()
		edges[i].w = nextInt()
	}

	sort.Slice(edges, func(i, j int) bool {
		return edges[i].w < edges[j].w
	})

	dsu := make([]int, 2*n)
	for i := 1; i < 2*n; i++ {
		dsu[i] = i
	}
	var find func(int) int
	find = func(x int) int {
		if dsu[x] == x {
			return x
		}
		dsu[x] = find(dsu[x])
		return dsu[x]
	}

	weight := make([]int, 2*n)
	for i := 1; i <= n; i++ {
		weight[i] = -1
	}

	adj := make([][]int, 2*n)
	for i := 0; i < n-1; i++ {
		e := edges[i]
		ru := find(e.u)
		rv := find(e.v)
		node := n + 1 + i
		weight[node] = e.w
		dsu[ru] = node
		dsu[rv] = node
		adj[node] = []int{ru, rv}
	}

	root := 2*n - 1

	up := make([][20]int, 2*n)
	depth := make([]int, 2*n)

	var dfs func(u, p, d int)
	dfs = func(u, p, d int) {
		up[u][0] = p
		depth[u] = d
		for i := 1; i < 20; i++ {
			up[u][i] = up[up[u][i-1]][i-1]
		}
		for _, v := range adj[u] {
			dfs(v, u, d+1)
		}
	}

	dfs(root, root, 0)

	get_lca := func(u, v int) int {
		if depth[u] < depth[v] {
			u, v = v, u
		}
		diff := depth[u] - depth[v]
		for i := 0; i < 20; i++ {
			if (diff & (1 << i)) != 0 {
				u = up[u][i]
			}
		}
		if u == v {
			return u
		}
		for i := 19; i >= 0; i-- {
			if up[u][i] != up[v][i] {
				u = up[u][i]
				v = up[v][i]
			}
		}
		return up[u][0]
	}

	tree := make([]Node, 4*n+1)

	var build func(node, l, r int)
	build = func(node, l, r int) {
		if l == r {
			tree[node].lca_all = l
			tree[node].lca_val = 0
			return
		}
		mid := (l + r) / 2
		build(2*node, l, mid)
		build(2*node+1, mid+1, r)
		tree[node].lca_all = get_lca(tree[2*node].lca_all, tree[2*node+1].lca_all)
		tree[node].lca_val = 0
	}

	build(1, 1, n)

	push_down := func(node int) {
		if tree[node].lazy == 1 {
			tree[2*node].lazy = 1
			tree[2*node].lca_val = tree[2*node].lca_all
			tree[2*node+1].lazy = 1
			tree[2*node+1].lca_val = tree[2*node+1].lca_all
			tree[node].lazy = 0
		} else if tree[node].lazy == 2 {
			tree[2*node].lazy = 2
			tree[2*node].lca_val = 0
			tree[2*node+1].lazy = 2
			tree[2*node+1].lca_val = 0
			tree[node].lazy = 0
		}
	}

	merge := func(u, v int) int {
		if u == 0 {
			return v
		}
		if v == 0 {
			return u
		}
		return get_lca(u, v)
	}

	var update func(node, l, r, ql, qr int, typ int8)
	update = func(node, l, r, ql, qr int, typ int8) {
		if ql <= l && r <= qr {
			tree[node].lazy = typ
			if typ == 1 {
				tree[node].lca_val = tree[node].lca_all
			} else {
				tree[node].lca_val = 0
			}
			return
		}
		push_down(node)
		mid := (l + r) / 2
		if ql <= mid {
			update(2*node, l, mid, ql, qr, typ)
		}
		if qr > mid {
			update(2*node+1, mid+1, r, ql, qr, typ)
		}
		tree[node].lca_val = merge(tree[2*node].lca_val, tree[2*node+1].lca_val)
	}

	for i := 0; i < q; i++ {
		typ := nextInt()
		if typ == 1 {
			l := nextInt()
			r := nextInt()
			update(1, 1, n, l, r, 1)
		} else if typ == 2 {
			l := nextInt()
			r := nextInt()
			update(1, 1, n, l, r, 2)
		} else {
			x := nextInt()
			L := tree[1].lca_val
			if L == 0 {
				writer.WriteString("-1\n")
			} else {
				ans_lca := get_lca(x, L)
				writer.WriteString(strconv.Itoa(weight[ans_lca]) + "\n")
			}
		}
	}
}
```