For problem statement at 1000-1999/1700-1799/1720-1729/1725/problemK.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1720-1729/1725/verifierK.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"io"
	"os"
)

var data []byte
var ptr int

func nextInt() int {
	n := len(data)
	for ptr < n && (data[ptr] < '0' || data[ptr] > '9') {
		ptr++
	}
	v := 0
	for ptr < n && data[ptr] >= '0' && data[ptr] <= '9' {
		v = v*10 + int(data[ptr]-'0')
		ptr++
	}
	return v
}

var parent []int
var gsize []int
var gheight []int
var ghead []int
var gtail []int
var gid []int
var prv []int
var nxt []int
var gCnt int

func find(x int) int {
	y := x
	for parent[y] != y {
		y = parent[y]
	}
	for parent[x] != x {
		p := parent[x]
		parent[x] = y
		x = p
	}
	return y
}

func unite(a, b int) int {
	if a == 0 {
		if b == 0 {
			return 0
		}
		return find(b)
	}
	if b == 0 {
		return find(a)
	}
	a = find(a)
	b = find(b)
	if a == b {
		return a
	}
	if gsize[a] < gsize[b] {
		a, b = b, a
	}
	if ghead[b] != 0 {
		if ghead[a] == 0 {
			ghead[a] = ghead[b]
			gtail[a] = gtail[b]
		} else {
			nxt[gtail[a]] = ghead[b]
			prv[ghead[b]] = gtail[a]
			gtail[a] = gtail[b]
		}
		gsize[a] += gsize[b]
	}
	parent[b] = a
	return a
}

func makeGroup(building, height int) int {
	gCnt++
	parent[gCnt] = gCnt
	gsize[gCnt] = 1
	gheight[gCnt] = height
	ghead[gCnt] = building
	gtail[gCnt] = building
	gid[building] = gCnt
	prv[building] = 0
	nxt[building] = 0
	return gCnt
}

var tKey []int
var tVal []int
var tLeft []int
var tRight []int
var tPrio []uint32
var tCnt int
var treapRoot int
var seed uint32 = 2463534242

func rand32() uint32 {
	seed ^= seed << 13
	seed ^= seed >> 17
	seed ^= seed << 5
	return seed
}

func newTreapNode(key, val int) int {
	tCnt++
	tKey[tCnt] = key
	tVal[tCnt] = val
	tPrio[tCnt] = rand32()
	tLeft[tCnt] = 0
	tRight[tCnt] = 0
	return tCnt
}

func split(cur, key int) (int, int) {
	if cur == 0 {
		return 0, 0
	}
	if tKey[cur] <= key {
		a, b := split(tRight[cur], key)
		tRight[cur] = a
		return cur, b
	}
	a, b := split(tLeft[cur], key)
	tLeft[cur] = b
	return a, cur
}

func merge(a, b int) int {
	if a == 0 {
		return b
	}
	if b == 0 {
		return a
	}
	if tPrio[a] > tPrio[b] {
		tRight[a] = merge(tRight[a], b)
		return a
	}
	tLeft[b] = merge(a, tLeft[b])
	return b
}

func insert(cur, node int) int {
	if cur == 0 {
		return node
	}
	if tPrio[node] > tPrio[cur] {
		l, r := split(cur, tKey[node])
		tLeft[node] = l
		tRight[node] = r
		return node
	}
	if tKey[node] < tKey[cur] {
		tLeft[cur] = insert(tLeft[cur], node)
	} else {
		tRight[cur] = insert(tRight[cur], node)
	}
	return cur
}

func deleteKey(cur, key int) int {
	if cur == 0 {
		return 0
	}
	if key < tKey[cur] {
		tLeft[cur] = deleteKey(tLeft[cur], key)
		return cur
	}
	if key > tKey[cur] {
		tRight[cur] = deleteKey(tRight[cur], key)
		return cur
	}
	return merge(tLeft[cur], tRight[cur])
}

func findNode(cur, key int) int {
	for cur != 0 {
		if key < tKey[cur] {
			cur = tLeft[cur]
		} else if key > tKey[cur] {
			cur = tRight[cur]
		} else {
			return cur
		}
	}
	return 0
}

func addGroupToHeight(groupID, height int) {
	node := findNode(treapRoot, height)
	if node != 0 {
		r := unite(tVal[node], groupID)
		r = find(r)
		gheight[r] = height
		tVal[node] = r
	} else {
		treapRoot = insert(treapRoot, newTreapNode(height, groupID))
	}
}

func detachBuilding(k int) {
	root := find(gid[k])
	h := gheight[root]
	p := prv[k]
	n := nxt[k]
	if p != 0 {
		nxt[p] = n
	} else {
		ghead[root] = n
	}
	if n != 0 {
		prv[n] = p
	} else {
		gtail[root] = p
	}
	prv[k] = 0
	nxt[k] = 0
	gsize[root]--
	if gsize[root] == 0 {
		treapRoot = deleteKey(treapRoot, h)
	}
}

var stk []int

func processRange(L, R, target int) {
	if L > R {
		return
	}
	a, b := split(treapRoot, L-1)
	mid, c := split(b, R)
	srcRoot := 0
	if mid != 0 {
		stk = stk[:0]
		cur := mid
		for cur != 0 || len(stk) > 0 {
			for cur != 0 {
				stk = append(stk, cur)
				cur = tLeft[cur]
			}
			cur = stk[len(stk)-1]
			stk = stk[:len(stk)-1]
			if srcRoot == 0 {
				srcRoot = tVal[cur]
			} else {
				srcRoot = unite(srcRoot, tVal[cur])
			}
			cur = tRight[cur]
		}
	}
	treapRoot = merge(a, c)
	if srcRoot == 0 {
		return
	}
	node := findNode(treapRoot, target)
	if node != 0 {
		srcRoot = unite(tVal[node], srcRoot)
		srcRoot = find(srcRoot)
		gheight[srcRoot] = target
		tVal[node] = srcRoot
	} else {
		srcRoot = find(srcRoot)
		gheight[srcRoot] = target
		treapRoot = insert(treapRoot, newTreapNode(target, srcRoot))
	}
}

func appendInt(dst []byte, x int) []byte {
	if x == 0 {
		dst = append(dst, '0', '\n')
		return dst
	}
	var buf [20]byte
	n := 0
	for x > 0 {
		buf[n] = byte('0' + x%10)
		x /= 10
		n++
	}
	for i := n - 1; i >= 0; i-- {
		dst = append(dst, buf[i])
	}
	dst = append(dst, '\n')
	return dst
}

func main() {
	data, _ = io.ReadAll(os.Stdin)

	N := nextInt()
	A := make([]int, N+1)
	for i := 1; i <= N; i++ {
		A[i] = nextInt()
	}
	Q := nextInt()

	parent = make([]int, N+Q+5)
	gsize = make([]int, N+Q+5)
	gheight = make([]int, N+Q+5)
	ghead = make([]int, N+Q+5)
	gtail = make([]int, N+Q+5)
	gid = make([]int, N+1)
	prv = make([]int, N+1)
	nxt = make([]int, N+1)

	tMax := N + 3*Q + 5
	tKey = make([]int, tMax)
	tVal = make([]int, tMax)
	tLeft = make([]int, tMax)
	tRight = make([]int, tMax)
	tPrio = make([]uint32, tMax)

	for i := 1; i <= N; i++ {
		id := makeGroup(i, A[i])
		addGroupToHeight(id, A[i])
	}

	out := make([]byte, 0, Q*12)

	for i := 0; i < Q; i++ {
		typ := nextInt()
		if typ == 1 {
			k := nextInt()
			w := nextInt()
			detachBuilding(k)
			id := makeGroup(k, w)
			addGroupToHeight(id, w)
		} else if typ == 2 {
			k := nextInt()
			out = appendInt(out, gheight[find(gid[k])])
		} else {
			l := nextInt()
			r := nextInt()
			m := (l + r + 1) >> 1
			processRange(l, m-1, l-1)
			processRange(m, r, r+1)
		}
	}

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