package main

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

const MOD = 998244353

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

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for i := 0; i < t; i++ {
		var n, m, A, B int64
		fmt.Fscan(reader, &n, &m, &A, &B)

		A_mod := A % MOD
		B_mod := B % MOD

		dp := make([]int64, 16)
		nextDp := make([]int64, 16)
		dp[15] = 1

		for k := 29; k >= 0; k-- {
			bitA := (A >> k) & 1
			bitB := (B >> k) & 1
			for j := 0; j < 16; j++ {
				nextDp[j] = 0
			}

			for mask := 0; mask < 16; mask++ {
				if dp[mask] == 0 {
					continue
				}
				tx1 := (mask >> 3) & 1
				tx2 := (mask >> 2) & 1
				ty1 := (mask >> 1) & 1
				ty2 := mask & 1

				for bx1 := int64(0); bx1 <= 1; bx1++ {
					if tx1 == 1 && bx1 > bitA {
						continue
					}
					ntx1 := tx1
					if bx1 < bitA {
						ntx1 = 0
					}

					for bx2 := int64(0); bx2 <= 1; bx2++ {
						if tx2 == 1 && bx2 > bitA {
							continue
						}
						ntx2 := tx2
						if bx2 < bitA {
							ntx2 = 0
						}

						for by1 := int64(0); by1 <= 1; by1++ {
							if ty1 == 1 && by1 > bitB {
								continue
							}
							nty1 := ty1
							if by1 < bitB {
								nty1 = 0
							}

							by2 := bx1 ^ bx2 ^ by1
							if ty2 == 1 && by2 > bitB {
								continue
							}
							nty2 := ty2
							if by2 < bitB {
								nty2 = 0
							}

							nmask := (ntx1 << 3) | (ntx2 << 2) | (nty1 << 1) | nty2
							nextDp[nmask] = (nextDp[nmask] + dp[mask]) % MOD
						}
					}
				}
			}
			dp, nextDp = nextDp, dp
		}

		var C int64 = 0
		for mask := 0; mask < 16; mask++ {
			C = (C + dp[mask]) % MOD
		}

		ways0 := (A_mod + 1) * (B_mod + 1) % MOD

		C = (C - ways0 + MOD) % MOD
		C = (C * 748683265) % MOD

		powN := (power(2, n) - 2 + MOD) % MOD
		powM := (power(2, m) - 2 + MOD) % MOD

		ans := ways0

		ans = (ans + (A_mod+1)*(B_mod+1)%MOD*B_mod%MOD*499122177%MOD*powM) % MOD
		ans = (ans + (B_mod+1)*(A_mod+1)%MOD*A_mod%MOD*499122177%MOD*powN) % MOD
		ans = (ans + powN*powM%MOD*C) % MOD

		fmt.Fprintln(writer, ans)
	}
}

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}