class SegmentTree:
	def __init__(self, n):
		tmp = 0
		while n != 0:
			n >>= 1
			tmp += 1
		self.seglen = 1 << tmp
		self.inf = 0
		self.seg = [self.inf]*(self.seglen*2)
	
	def update(self, x, val):
		# update x to val;
		x += self.seglen
		self.seg[x] = val
		while x > 1:
			x >>= 1
			self.seg[x] = max(self.seg[2*x], self.seg[2*x+1])
	
	def allupdate(self, a):
		targ = self.seglen
		for i in range(len(a)):
			self.seg[targ + i] = a[i]
		for i in range(self.seglen-1, -1, -1):
			self.seg[i] = max(self.seg[2*i], self.seg[2*i+1])

	def query(self, l, r):
		l = max(l, 0) + self.seglen
		r = max(r, 0) + self.seglen
		lres, rres = self.inf, self.inf
		while l < r:
			if l & 1:
				lres = max(lres, self.seg[l])
				l += 1
			if r & 1:
				r -= 1
				rres = max(rres, self.seg[r])
			l >>= 1
			r >>= 1
		return max(lres, rres)

def compress(arr):
	*XS, = set(arr)
	XS.sort()
	return {cmp_e: cmp_i for cmp_i, cmp_e in enumerate(XS)}

h,w,n,p = map(int,input().split())
ys = []
bucket = [[] for i in range(h)]
for i in range(n):
	x, y = map(int,input().split())
	bucket[x-1].append(y-1)
	ys.append(y-1)
y_c = compress(ys)
m = len(y_c)

seg = SegmentTree(m)
for i in range(h):
	bucket[i].sort()
	for j in bucket[i]:
		targ = y_c[j]
		ast = seg.query(0, targ+1) + 1
		ar = seg.query(targ, targ + 1)
		seg.update(targ, max(ar, ast))

tmp = seg.query(0, m)

mod = 998244353
yes = (1 - 2 * pow(p, mod-2, mod)) % mod
no = (1 - pow(p, mod-2, mod)) % mod

def best_fraction(n:int, mod:int, strmode=0) -> tuple:
	w = 9 * 10 ** 18
	t = pow(n, mod-2, mod)
	ansx, ansy = 0, 0
	for b in range(1, mod):
		if b*b > w: break
		a = n*b % mod
		c = t*b % mod
		if a*b < w:
			w = a*b
			ansx, ansy = a, b
		if c*b < w:
			w = c*b
			ansx, ansy = b, c
	if strmode:
		return f"{n} = {ansx}/{ansy} (mod {mod})"
	return (ansx, ansy)


ans = (1 - pow(yes, tmp, mod) * pow(no, h+w-3-tmp, mod)) % mod
print(ans)
#print(best_fraction(ans, mod, 1))