#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
 
const int MOD = 998244353;
 
// Fast modular exponentiation mod MOD.
ll modexp(ll base, ll exp) {
    ll res = 1 % MOD;
    base %= MOD;
    while(exp > 0){
        if(exp & 1) res = (res * base) % MOD;
        base = (base * base) % MOD;
        exp >>= 1;
    }
    return res;
}
 
// Iterative digit DP to compute Q(A,B):
// Q(A,B) = number of quadruples (p,q,r,s) with 0 <= p < q <= A, 0 <= r < s <= B
// such that p XOR q equals r XOR s, computed mod MOD.
ll computeQuadrupleCount(ll A_val, ll B_val) {
    // Compute bit–lengths.
    int bitsA = 0, bitsB = 0;
    {
        ll tmp = A_val;
        if(tmp == 0) bitsA = 1;
        else while(tmp > 0){ bitsA++; tmp >>= 1; }
    }
    {
        ll tmp = B_val;
        if(tmp == 0) bitsB = 1;
        else while(tmp > 0){ bitsB++; tmp >>= 1; }
    }
    int R = max(bitsA, bitsB);
 
    // Build binary representations (length R, index 0 = MSB).
    vector<int> A_bits(R, 0), B_bits(R, 0);
    for (int i = 0; i < R; i++){
        int pos = R - 1 - i;
        A_bits[i] = ((A_val >> pos) & 1LL) ? 1 : 0;
    }
    for (int i = 0; i < R; i++){
        int pos = R - 1 - i;
        B_bits[i] = ((B_val >> pos) & 1LL) ? 1 : 0;
    }
 
    // Our DP state for each pair consists of 3 bits:
    // For the A–pair (p,q): 
    //   - ta: whether p is still “tight” with A’s prefix,
    //   - tb: whether q is still “tight”,
    //   - oa: order flag (0 means not yet determined that p < q; 1 means p < q already).
    // For the B–pair (r,s): similarly (tu, tv, ob).
    // We encode these 6 flags into an integer (bits: ta at bit5, tb at bit4, oa at bit3,
    // tu at bit2, tv at bit1, ob at bit0). (There are 64 states.)
    const int STATE_COUNT = 1 << 6; 
    // dp[i][state]: number of ways to assign bits from position i to R-1.
    vector<vector<ll>> dp(R+1, vector<ll>(STATE_COUNT, 0));
    // initial state: for A–pair, ta=1, tb=1, oa=0; for B–pair, tu=1, tv=1, ob=0.
    // That is encoded as: (1<<5) | (1<<4) | (0<<3) | (1<<2) | (1<<1) | (0) = 54.
    dp[0][54] = 1;
 
    // Process positions 0..R-1.
    for (int pos = 0; pos < R; pos++){
        int A_cur = A_bits[pos]; // current bit of A
        int B_cur = B_bits[pos]; // current bit of B
        for (int st = 0; st < STATE_COUNT; st++){
            ll ways = dp[pos][st];
            if(!ways) continue;
            // Decode state:
            int ta = (st >> 5) & 1;  // A–pair: p is tight?
            int tb = (st >> 4) & 1;  // A–pair: q is tight?
            int oa = (st >> 3) & 1;  // A–pair: order determined? (p < q)
            int tu = (st >> 2) & 1;  // B–pair: r is tight?
            int tv = (st >> 1) & 1;  // B–pair: s is tight?
            int ob = st & 1;         // B–pair: order determined? (r < s)
 
            // For the A–pair, choose bits (aBit, bBit) for (p, q).
            // If order is not yet determined (oa==0), we disallow (1,0) because that would make p > q.
            vector<pair<int,int>> choicesA;
            if(oa == 0){
                choicesA.push_back({0,0});
                choicesA.push_back({0,1});
                choicesA.push_back({1,1});
            } else {
                // If order is already determined, any pair is allowed.
                choicesA.push_back({0,0});
                choicesA.push_back({0,1});
                choicesA.push_back({1,0});
                choicesA.push_back({1,1});
            }
            // Similarly for the B–pair.
            vector<pair<int,int>> choicesB;
            if(ob == 0){
                choicesB.push_back({0,0});
                choicesB.push_back({0,1});
                choicesB.push_back({1,1});
            } else {
                choicesB.push_back({0,0});
                choicesB.push_back({0,1});
                choicesB.push_back({1,0});
                choicesB.push_back({1,1});
            }
 
            for(auto &pChoice: choicesA) {
                int aBit = pChoice.first, bBit = pChoice.second;
                // Check tight constraints for A: if still tight, the chosen bit cannot exceed the corresponding bit of A.
                if(ta && aBit > A_cur) continue;
                if(tb && bBit > A_cur) continue;
                int nta = (ta && (aBit == A_cur)) ? 1 : 0;
                int ntb = (tb && (bBit == A_cur)) ? 1 : 0;
                // Update order flag: if not already determined and aBit < bBit, then order becomes determined.
                int noa = oa;
                if(oa == 0 && aBit < bBit) noa = 1;
 
                for(auto &rChoice: choicesB) {
                    int uBit = rChoice.first, vBit = rChoice.second;
                    if(tu && uBit > B_cur) continue;
                    if(tv && vBit > B_cur) continue;
                    int ntu = (tu && (uBit == B_cur)) ? 1 : 0;
                    int ntv = (tv && (vBit == B_cur)) ? 1 : 0;
                    int nob = ob;
                    if(ob == 0 && uBit < vBit) nob = 1;
 
                    // Enforce: (aBit XOR bBit) must equal (uBit XOR vBit)
                    if((aBit ^ bBit) != (uBit ^ vBit)) continue;
 
                    int nst = (nta << 5) | (ntb << 4) | (noa << 3) | (ntu << 2) | (ntv << 1) | (nob);
                    dp[pos+1][nst] = (dp[pos+1][nst] + ways) % MOD;
                }
            }
        }
    }
    // Sum over final states (pos==R) that have order flags 1 for both pairs (i.e. p<q and r<s hold).
    ll res = 0;
    for (int st = 0; st < STATE_COUNT; st++){
        int oa = (st >> 3) & 1;
        int ob = st & 1;
        if(oa == 1 && ob == 1)
            res = (res + dp[R][st]) % MOD;
    }
    return res;
}
 
// Main – combine the four cases.
int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int t;
    cin >> t;
    while(t--){
        // Read: n, m, A, B.
        ll n, m, A, B;
        cin >> n >> m >> A >> B;
 
        // Case 1: Both arrays constant.
        ll case1 = ((A + 1) % MOD) * ((B + 1) % MOD) % MOD;
 
        // Precompute 2^n and 2^m mod MOD.
        ll two_n = modexp(2, n);
        ll two_m = modexp(2, m);
 
        // For arrays that are exactly 2–valued, the count is:
        //   (number of ways to choose an unordered pair from [0,X]) * (2^L - 2)
        // with X = A for a and X = B for b.
        ll chooseA = (((A + 1) * A) / 2) % MOD; // = binom(A+1,2)
        ll chooseB = (((B + 1) * B) / 2) % MOD; // = binom(B+1,2)
 
        // Case 2: a constant, b exactly 2–valued.
        ll case2 = ((A + 1) % MOD) * (chooseB * ((two_m - 2 + MOD) % MOD) % MOD) % MOD;
 
        // Case 3: a exactly 2–valued, b constant.
        ll case3 = ((B + 1) % MOD) * (chooseA * ((two_n - 2 + MOD) % MOD) % MOD) % MOD;
 
        // Case 4: both arrays exactly 2–valued AND the two chosen unordered pairs have the same XOR difference.
        ll QAB = computeQuadrupleCount(A, B); // computed mod MOD
        ll case4 = (((two_n - 2 + MOD) % MOD) * ((two_m - 2 + MOD) % MOD)) % MOD;
        case4 = (case4 * QAB) % MOD;
 
        ll ans = (case1 + case2 + case3 + case4) % MOD;
        if(ans < 0) ans += MOD;
        cout << ans % MOD << "\n";
    }
    return 0;
}