For problem statement at 1000-1999/1200-1299/1280-1289/1286/problemD.txt this is a correct solution, but verifier at 1000-1999/1200-1299/1280-1289/1286/verifierD.go ends with case 11 failed: expected 569888156 got 240467521
input:
6
4 4 30
6 5 39
7 3 86
8 5 15
10 4 6
12 4 15
exit status 1 can you fix the verifier? package main

import (
	"fmt"
	"io"
	"os"
	"sort"
)

const MOD int64 = 998244353

type Mat struct {
	a00, a01, a10, a11 int64
}

func mul(x, y Mat) Mat {
	return Mat{
		(x.a00*y.a00 + x.a01*y.a10) % MOD,
		(x.a00*y.a01 + x.a01*y.a11) % MOD,
		(x.a10*y.a00 + x.a11*y.a10) % MOD,
		(x.a10*y.a01 + x.a11*y.a11) % MOD,
	}
}

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

type Event struct {
	num, den int64
	edge     int
	code     int
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int64 {
		for idx < len(data) {
			c := data[idx]
			if c == ' ' || c == '\n' || c == '\r' || c == '\t' {
				idx++
			} else {
				break
			}
		}
		sign := int64(1)
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		val := int64(0)
		for idx < len(data) {
			c := data[idx]
			if c < '0' || c > '9' {
				break
			}
			val = val*10 + int64(c-'0')
			idx++
		}
		return sign * val
	}

	n := int(nextInt())
	x := make([]int64, n)
	v := make([]int64, n)
	wl := make([]int64, n)
	wr := make([]int64, n)

	inv100 := powMod(100, MOD-2)
	for i := 0; i < n; i++ {
		x[i] = nextInt()
		v[i] = nextInt()
		p := nextInt()
		wr[i] = p % MOD * inv100 % MOD
		wl[i] = (100 - p) % MOD * inv100 % MOD
	}

	if n == 1 {
		fmt.Println(0)
		return
	}

	m := n - 1
	mats := make([]Mat, m)
	events := make([]Event, 0, 3*m)

	for i := 0; i < m; i++ {
		mats[i] = Mat{wl[i+1], wr[i+1], wl[i+1], wr[i+1]}
		d := x[i+1] - x[i]
		events = append(events, Event{d, v[i] + v[i+1], i, 1})
		if v[i] > v[i+1] {
			events = append(events, Event{d, v[i] - v[i+1], i, 2})
		}
		if v[i] < v[i+1] {
			events = append(events, Event{d, v[i+1] - v[i], i, 0})
		}
	}

	size := 1
	for size < m {
		size <<= 1
	}
	id := Mat{1, 0, 0, 1}
	tree := make([]Mat, 2*size)
	for i := 0; i < size; i++ {
		tree[size+i] = id
	}
	for i := 0; i < m; i++ {
		tree[size+i] = mats[i]
	}
	for i := size - 1; i > 0; i-- {
		tree[i] = mul(tree[i<<1], tree[i<<1|1])
	}

	update := func(pos int, val Mat) {
		p := size + pos
		tree[p] = val
		for p >>= 1; p > 0; p >>= 1 {
			tree[p] = mul(tree[p<<1], tree[p<<1|1])
		}
	}

	getProb := func() int64 {
		root := tree[1]
		s0 := root.a00 + root.a01
		if s0 >= MOD {
			s0 -= MOD
		}
		s1 := root.a10 + root.a11
		if s1 >= MOD {
			s1 -= MOD
		}
		return (wl[0]*s0 + wr[0]*s1) % MOD
	}

	sort.Slice(events, func(i, j int) bool {
		return events[i].num*events[j].den < events[j].num*events[i].den
	})

	prev := getProb()
	ans := int64(0)

	for i := 0; i < len(events); {
		j := i + 1
		for j < len(events) && events[j].num*events[i].den == events[i].num*events[j].den {
			j++
		}

		for k := i; k < j; k++ {
			ev := events[k]
			mat := mats[ev.edge]
			if ev.code == 0 {
				mat.a00 = 0
			} else if ev.code == 1 {
				mat.a10 = 0
			} else {
				mat.a11 = 0
			}
			mats[ev.edge] = mat
			update(ev.edge, mat)
		}

		cur := getProb()
		diff := prev - cur
		if diff < 0 {
			diff += MOD
		}
		tmod := events[i].num % MOD * powMod(events[i].den%MOD, MOD-2) % MOD
		ans = (ans + tmod*diff) % MOD
		prev = cur
		i = j
	}

	fmt.Println(ans)
}