```go
package main

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

const MOD int64 = 998244353
const OFF = 200
const SZ = 401

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

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

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

	inv1e6 := powmod(1000000, MOD-2)

	xUsed := make([]bool, 101)
	yUsed := make([]bool, 101)
	dUsed := make([]bool, SZ)
	sUsed := make([]bool, SZ)
	failD := make([]int64, SZ)
	failS := make([]int64, SZ)
	for i := 0; i < SZ; i++ {
		failD[i] = 1
		failS[i] = 1
	}

	xCnt, yCnt := 0, 0

	for i := 0; i < n; i++ {
		var x, y, pp int
		fmt.Fscan(in, &x, &y, &pp)

		if !xUsed[x] {
			xUsed[x] = true
			xCnt++
		}
		if !yUsed[y] {
			yUsed[y] = true
			yCnt++
		}

		p := int64(pp) * inv1e6 % MOD
		comp := (1 - p + MOD) % MOD

		di := x - y + OFF
		si := x + y + OFF

		dUsed[di] = true
		sUsed[si] = true
		failD[di] = failD[di] * comp % MOD
		failS[si] = failS[si] * comp % MOD
	}

	qD := make([]int64, SZ)
	qS := make([]int64, SZ)

	ans := int64(1+xCnt+yCnt) % MOD

	for i := 0; i < SZ; i++ {
		if dUsed[i] {
			qD[i] = (1 - failD[i] + MOD) % MOD
			ans += qD[i]
		}
		if sUsed[i] {
			qS[i] = (1 - failS[i] + MOD) % MOD
			ans += qS[i]
		}
	}
	ans %= MOD

	for x := 1; x < a; x++ {
		for y := 1; y < b; y++ {
			c := 0
			if xUsed[x] {
				c++
			}
			if yUsed[y] {
				c++
			}

			di := x - y + OFF
			si := x + y + OFF

			hasP := dUsed[di]
			hasM := sUsed[si]

			if c > 0 {
				ans += int64(c - 1)
				if hasP {
					ans += qD[di]
				}
				if hasM {
					ans += qS[si]
				}
			} else if hasP && hasM {
				ans += qD[di] * qS[si] % MOD
			}

			ans %= MOD
		}
	}

	for u := 1; u < 2*a; u += 2 {
		for v := 1; v < 2*b; v += 2 {
			di := (u-v)/2 + OFF
			si := (u+v)/2 + OFF
			if dUsed[di] && sUsed[si] {
				ans += qD[di] * qS[si] % MOD
				ans %= MOD
			}
		}
	}

	fmt.Fprintln(out, ans%MOD)
}
```