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

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

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024*10)

	scanInt := func() int {
		scanner.Scan()
		res, _ := strconv.Atoi(scanner.Text())
		return res
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	m := scanInt()

	u := make([]int, m)
	v := make([]int, m)
	w := make([]int, m)
	for i := 0; i < m; i++ {
		u[i] = scanInt() - 1
		v[i] = scanInt() - 1
		w[i] = scanInt()
	}

	p := scanInt()
	k_total := scanInt()
	a := int64(scanInt())
	b := int64(scanInt())
	c := int64(scanInt())

	queries := make([]int64, p)
	for i := 0; i < p; i++ {
		queries[i] = int64(scanInt())
	}

	M_values := make([]int, 0, m*m/2+2)
	M_values = append(M_values, -1, 200000000)
	for i := 0; i < m; i++ {
		for j := i; j < m; j++ {
			M_values = append(M_values, (w[i]+w[j])/2)
		}
	}
	sort.Ints(M_values)
	uniqueM := M_values[:1]
	for i := 1; i < len(M_values); i++ {
		if M_values[i] != M_values[i-1] {
			uniqueM = append(uniqueM, M_values[i])
		}
	}

	K := len(uniqueM) - 1
	intervalA := make([]int64, K)
	intervalB := make([]int64, K)
	intervalEnd := make([]int, K)

	edges := make([]int, m)
	for i := 0; i < m; i++ {
		edges[i] = i
	}

	parent := make([]int, n)
	for i := range parent {
		parent[i] = i
	}

	for k := 0; k < K; k++ {
		M_i := uniqueM[k]
		M_next := uniqueM[k+1]

		for j := 1; j < m; j++ {
			key := edges[j]
			idx := j - 1
			for idx >= 0 {
				e1 := key
				e2 := edges[idx]
				d1 := w[e1] - M_next
				if d1 < 0 {
					d1 = -d1
				}
				d2 := w[e2] - M_next
				if d2 < 0 {
					d2 = -d2
				}

				isLess := false
				if d1 != d2 {
					isLess = d1 < d2
				} else {
					isLess = w[e1] < w[e2]
				}

				if isLess {
					edges[idx+1] = edges[idx]
					idx--
				} else {
					break
				}
			}
			edges[idx+1] = key
		}

		for i := range parent {
			parent[i] = i
		}

		var A, B int64
		edgesUsed := 0

		for _, e := range edges {
			rootU := u[e]
			for rootU != parent[rootU] {
				rootU = parent[rootU]
			}
			curr := u[e]
			for curr != rootU {
				nxt := parent[curr]
				parent[curr] = rootU
				curr = nxt
			}

			rootV := v[e]
			for rootV != parent[rootV] {
				rootV = parent[rootV]
			}
			curr = v[e]
			for curr != rootV {
				nxt := parent[curr]
				parent[curr] = rootV
				curr = nxt
			}

			if rootU != rootV {
				parent[rootU] = rootV
				if w[e] <= M_i {
					A += 1
					B -= int64(w[e])
				} else {
					A -= 1
					B += int64(w[e])
				}
				edgesUsed++
				if edgesUsed == n-1 {
					break
				}
			}
		}

		intervalA[k] = A
		intervalB[k] = B
		intervalEnd[k] = M_next
	}

	var ans int64 = 0
	var lastQ int64

	for j := 1; j <= k_total; j++ {
		var q int64
		if j <= p {
			q = queries[j-1]
		} else {
			q = (lastQ*a + b) % c
		}
		lastQ = q

		left, right := 0, K-1
		var idx int
		for left <= right {
			mid := (left + right) / 2
			if intervalEnd[mid] >= int(q) {
				idx = mid
				right = mid - 1
			} else {
				left = mid + 1
			}
		}

		cost := intervalA[idx]*q + intervalB[idx]
		ans ^= cost
	}

	fmt.Println(ans)
}