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 Test 2 failed
Input:
4 8 725576 54
Expected:
33
0
48
42
Got:
33
0
48
0


exit status 1 can you fix the verifier? package main

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

var seed int64

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

type node struct {
	l, r int
	v    int64
}

var tree []node

func split(pos int) int {
	idx := sort.Search(len(tree), func(i int) bool {
		return tree[i].r >= pos
	})
	if idx == len(tree) {
		return len(tree)
	}
	if tree[idx].l == pos {
		return idx
	}
	tree = append(tree, node{})
	copy(tree[idx+2:], tree[idx+1:])
	tree[idx+1] = node{pos, tree[idx].r, tree[idx].v}
	tree[idx].r = pos - 1
	return idx + 1
}

func assign(l, r int, v int64) {
	ir := split(r + 1)
	il := split(l)
	tree[il] = node{l, r, v}
	tree = append(tree[:il+1], tree[ir:]...)
}

func add(l, r int, v int64) {
	ir := split(r + 1)
	il := split(l)
	for i := il; i < ir; i++ {
		tree[i].v += v
	}
}

type pair struct {
	v     int64
	count int
}

func kth(l, r int, k int) int64 {
	ir := split(r + 1)
	il := split(l)
	arr := make([]pair, 0, ir-il)
	for i := il; i < ir; i++ {
		arr = append(arr, pair{tree[i].v, tree[i].r - tree[i].l + 1})
	}
	sort.Slice(arr, func(i, j int) bool {
		return arr[i].v < arr[j].v
	})
	for _, p := range arr {
		k -= p.count
		if k <= 0 {
			return p.v
		}
	}
	return -1
}

func power(base, exp, mod int64) int64 {
	res := int64(1)
	base %= mod
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % mod
		}
		base = (base * base) % mod
		exp /= 2
	}
	return res
}

func sumPow(l, r int, x, y int64) int64 {
	ir := split(r + 1)
	il := split(l)
	var ans int64
	for i := il; i < ir; i++ {
		count := int64(tree[i].r - tree[i].l + 1)
		val := power(tree[i].v%y, x, y)
		ans = (ans + val*(count%y)) % y
	}
	return ans
}

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

	var n, m int
	var vmax int64
	fmt.Fscan(in, &n, &m, &seed, &vmax)

	tree = make([]node, n)
	for i := 1; i <= n; i++ {
		tree[i-1] = node{i, i, (rnd() % vmax) + 1}
	}

	for i := 1; 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
		}

		if op == 1 {
			add(l, r, x)
		} else if op == 2 {
			assign(l, r, x)
		} else if op == 3 {
			fmt.Fprintln(out, kth(l, r, int(x)))
		} else if op == 4 {
			fmt.Fprintln(out, sumPow(l, r, x, y))
		}
	}
}