For problem statement at 0-999/800-899/890-899/896/problemC.txt this is a correct solution, but verifier at 0-999/800-899/890-899/896/verifierC.go ends with Passed 100 tests can you fix the verifier? ```go
package main

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

type Node struct {
	l, r  int
	v     int64
	p     uint64
	left  *Node
	right *Node
}

var (
	root      *Node
	n, m      int
	seed      int64
	vmax      int64
	out       = bufio.NewWriter(os.Stdout)
	treapSeed uint64 = 146527
)

const MOD int64 = 1000000007

func rnd() int64 {
	ret := seed
	seed = (seed*7 + 13) % MOD
	return ret
}

func trand() uint64 {
	treapSeed ^= treapSeed << 7
	treapSeed ^= treapSeed >> 9
	return treapSeed
}

func newNode(l, r int, v int64) *Node {
	return &Node{l: l, r: r, v: v, p: trand()}
}

func merge(a, b *Node) *Node {
	if a == nil {
		return b
	}
	if b == nil {
		return a
	}
	if a.p < b.p {
		a.right = merge(a.right, b)
		return a
	}
	b.left = merge(a, b.left)
	return b
}

func splitTreap(t *Node, key int) (*Node, *Node) {
	if t == nil {
		return nil, nil
	}
	if t.l < key {
		u, v := splitTreap(t.right, key)
		t.right = u
		return t, v
	}
	u, v := splitTreap(t.left, key)
	t.left = v
	return u, t
}

func getRightmost(t *Node) *Node {
	if t == nil {
		return nil
	}
	for t.right != nil {
		t = t.right
	}
	return t
}

func splitAt(pos int) {
	a, b := splitTreap(root, pos)
	if a != nil {
		rm := getRightmost(a)
		if rm != nil && rm.r >= pos {
			a1, temp := splitTreap(a, rm.l)
			mid, a2 := splitTreap(temp, rm.l+1)
			_ = mid
			leftNode := newNode(rm.l, pos-1, rm.v)
			a = merge(a1, merge(leftNode, a2))
			rightNode := newNode(pos, rm.r, rm.v)
			b = merge(rightNode, b)
		}
	}
	root = merge(a, b)
}

func inorderAdd(t *Node, delta int64) {
	if t == nil {
		return
	}
	inorderAdd(t.left, delta)
	t.v += delta
	inorderAdd(t.right, delta)
}

type pair struct {
	v   int64
	cnt int
}

func collectPairs(t *Node, res *[]pair) {
	if t == nil {
		return
	}
	collectPairs(t.left, res)
	*res = append(*res, pair{t.v, t.r - t.l + 1})
	collectPairs(t.right, res)
}

func powmod(a, e, mod int64) int64 {
	if mod == 1 {
		return 0
	}
	a %= mod
	res := int64(1 % mod)
	for e > 0 {
		if e&1 == 1 {
			res = (res * a) % mod
		}
		a = (a * a) % mod
		e >>= 1
	}
	return res
}

func main() {
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &n, &m, &seed, &vmax)

	if n > 0 {
		curL := 1
		curV := (rnd()%vmax + 1)
		for i := 2; i <= n; i++ {
			val := rnd()%vmax + 1
			if val != curV {
				root = merge(root, newNode(curL, i-1, curV))
				curL = i
				curV = val
			}
		}
		root = merge(root, newNode(curL, n, curV))
	}

	for i := 0; i < m; i++ {
		op := int(rnd()%4) + 1
		l := int(rnd()%int64(n)) + 1
		r := int(rnd()%int64(n)) + 1
		if l > r {
			l, r = r, l
		}
		var x, y int64
		if op == 3 {
			x = rnd()%int64(r-l+1) + 1
		} else {
			x = rnd()%vmax + 1
		}
		if op == 4 {
			y = rnd()%vmax + 1
		}

		splitAt(l)
		splitAt(r + 1)
		left, rest := splitTreap(root, l)
		mid, right := splitTreap(rest, r+1)

		switch op {
		case 1:
			inorderAdd(mid, x)
			root = merge(left, merge(mid, right))
		case 2:
			mid = nil
			mid = newNode(l, r, x)
			root = merge(left, merge(mid, right))
		case 3:
			var arr []pair
			collectPairs(mid, &arr)
			sort.Slice(arr, func(i, j int) bool { return arr[i].v < arr[j].v })
			k := int(x)
			ans := int64(0)
			for _, p := range arr {
				if k > p.cnt {
					k -= p.cnt
				} else {
					ans = p.v
					break
				}
			}
			fmt.Fprintln(out, ans)
			root = merge(left, merge(mid, right))
		case 4:
			mod := y
			sum := int64(0)
			var stack []pair
			collectPairs(mid, &stack)
			for _, p := range stack {
				pv := powmod(p.v%mod, x, mod)
				sum = (sum + (pv*(int64(p.cnt)%mod))%mod) % mod
			}
			fmt.Fprintln(out, sum%mod)
			root = merge(left, merge(mid, right))
		}
	}

	out.Flush()
}
```