```go
package main

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

var (
	n, m int
	seed int64
	vmax int64
	nodes []node
)

type node struct {
	l, r int
	v    int64
}

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

func split(pos int) int {
	idx := sort.Search(len(nodes), func(i int) bool {
		return nodes[i].l >= pos
	})
	if idx < len(nodes) && nodes[idx].l == pos {
		return idx
	}
	idx--
	if idx < 0 {
		return 0
	}
	if nodes[idx].r < pos {
		return idx + 1
	}

	R, V := nodes[idx].r, nodes[idx].v
	nodes[idx].r = pos - 1
	newNode := node{l: pos, r: R, v: V}

	nodes = append(nodes, node{})
	copy(nodes[idx+2:], nodes[idx+1:])
	nodes[idx+1] = newNode
	return idx + 1
}

func assign(l, r int, v int64) {
	itrL := split(l)
	itrR := split(r + 1)
	nodes[itrL].r = r
	nodes[itrL].v = v
	if itrL+1 < itrR {
		nodes = append(nodes[:itrL+1], nodes[itrR:]...)
	}
}

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

type pair struct {
	v int64
	c int
}

func kth(l, r, k int) int64 {
	itrL := split(l)
	itrR := split(r + 1)
	var ps []pair
	for i := itrL; i < itrR; i++ {
		ps = append(ps, pair{v: nodes[i].v, c: nodes[i].r - nodes[i].l + 1})
	}
	sort.Slice(ps, func(i, j int) bool {
		return ps[i].v < ps[j].v
	})
	for _, p := range ps {
		if k <= p.c {
			return p.v
		}
		k -= p.c
	}
	return -1
}

func fastPow(a, b, m int64) int64 {
	res := int64(1)
	a %= m
	for b > 0 {
		if b&1 == 1 {
			res = (res * a) % m
		}
		a = (a * a) % m
		b >>= 1
	}
	return res
}

func sumPow(l, r, x, y int) int64 {
	itrL := split(l)
	itrR := split(r + 1)
	var res int64
	mod := int64(y)
	exp := int64(x)
	for i := itrL; i < itrR; i++ {
		cnt := int64(nodes[i].r - nodes[i].l + 1)
		val := fastPow(nodes[i].v, exp, mod)
		res = (res + cnt*val) % mod
	}
	return res
}

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

	fmt.Fscan(reader, &n, &m, &seed, &vmax)

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

	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
		}

		switch op {
		case 1:
			add(l, r, x)
		case 2:
			assign(l, r, x)
		case 3:
			fmt.Fprintln(writer, kth(l, r, int(x)))
		case 4:
			fmt.Fprintln(writer, sumPow(l, r, int(x), int(y)))
		}
	}
}
```