```go
package main

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

const MOD int64 = 998244353

type Fenwick struct {
	n    int
	tree []int64
}

func NewFenwick(n int) *Fenwick {
	return &Fenwick{
		n:    n,
		tree: make([]int64, n+2),
	}
}

func (f *Fenwick) Update(i int, val int64) {
	for i <= f.n {
		f.tree[i] = (f.tree[i] + val) % MOD
		i += i & -i
	}
}

func (f *Fenwick) Query(i int) int64 {
	var res int64 = 0
	for i > 0 {
		res = (res + f.tree[i]) % MOD
		i -= i & -i
	}
	return res
}

func (f *Fenwick) RangeQuery(l, r int) int64 {
	if l > r {
		return 0
	}
	res := f.Query(r) - f.Query(l-1)
	res %= MOD
	if res < 0 {
		res += MOD
	}
	return res
}

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

	var n int
	fmt.Fscan(in, &n)

	x := make([]int64, n+1)
	y := make([]int64, n+1)
	s := make([]int, n+1)

	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &x[i], &y[i], &s[i])
	}

	bit := NewFenwick(n)
	var ans int64 = (x[n] + 1) % MOD

	for i := 1; i <= n; i++ {
		l := 1
		if i > 1 {
			sz := i - 1
			pos := sort.Search(sz, func(j int) bool {
				return x[1+j] > y[i]
			})
			l = 1 + pos
		}

		var sum int64 = 0
		if l <= i-1 {
			sum = bit.RangeQuery(l, i-1)
		}

		dp := (x[i] - y[i] + sum) % MOD
		if dp < 0 {
			dp += MOD
		}

		if s[i] == 1 {
			ans = (ans + dp) % MOD
		}

		bit.Update(i, dp)
	}

	ans %= MOD
	if ans < 0 {
		ans += MOD
	}
	fmt.Fprintln(out, ans)
}
```