#include <bits/stdc++.h>
using namespace std;

const int MOD = 998244353;

// 快速幂求解 a^b (mod mod)
long long modexp(long long a, long long b, int mod) {
    long long res = 1;
    while(b){
        if(b & 1) res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}

// 模逆元：利用费马小定理（MOD 为素数）
long long modinv(long long a, int mod) {
    return modexp(a, mod - 2, mod);
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int m, n, x, y;
    cin >> m >> n >> x >> y;
    // 为方便计算，确保 x <= y
    if(x > y) swap(x, y);

    // 预处理组合数：最大值设为 m+n+10，足够覆盖所有用到的数值
    int maxVal = m + n + 10;
    vector<long long> fact(maxVal), invfact(maxVal);
    fact[0] = 1;
    for (int i = 1; i < maxVal; i++){
        fact[i] = fact[i-1] * i % MOD;
    }
    invfact[maxVal-1] = modinv(fact[maxVal-1], MOD);
    for (int i = maxVal - 2; i >= 0; i--){
        invfact[i] = invfact[i+1] * (i+1) % MOD;
    }

    // 组合数函数
    auto C = [&](int a, int b) -> long long {
        if(b < 0 || b > a) return 0;
        return fact[a] * invfact[b] % MOD * invfact[a-b] % MOD;
    };

    long long ans = 0;
    // 情况1：两个地标均在前半部分，即 1 <= x <= y <= n
    if(y <= n){
        long long sumA = 0;
        // 固定一个高度 h  (1 <= h <= m)
        // 前半部分 A[1..n]需满足：A[x]=A[y]=h，
        // 且 A 为非递减序列：
        // - A[1..(x-1)]：取值在 [1,h]，方案数 C(h+x-2, x-1)
        // - A[x..y]：必须全等于 h（只有1种方案）
        // - A[(y+1)..n]：取值在 [h,m]，转化变量后方案数 C(m-h+n-y, n-y)
        for (int h = 1; h <= m; h++){
            long long waysFirst = C(h + x - 2, x - 1);
            long long waysThird = C(m - h + n - y, n - y);
            sumA = (sumA + waysFirst * waysThird) % MOD;
        }
        // 后半部分（建筑编号 n+1 .. 2n）为非递增序列，其方案数为 C(m+n-1, n)
        long long countB = C(m + n - 1, n);
        ans = sumA * countB % MOD;
    }
    // 情况2：两个地标均在后半部分，即 x, y > n
    else if(x > n){
        // 令 p = x - n, q = y - n, 则 p,q 属于 B[1..n]
        int p = x - n, q = y - n;
        long long sumB = 0;
        // 对于非递增序列 B[1..n]（表示建筑编号 n+1 到 2n），要求 B[p]=B[q]=h，
        // 可转化为：
        // - B[1..(p-1)]：取值在 [h,m]，转换后方案数 C(m-h+p-1, p-1)
        // - B[p..q]：固定为 h（1种方案）
        // - B[(q+1)..n]：取值在 [1,h]，转换后方案数 C(h+n-q-1, n-q)
        for (int h = 1; h <= m; h++){
            long long waysFirst = C(m - h + p - 1, p - 1);
            long long waysThird = C(h + n - q - 1, n - q);
            sumB = (sumB + waysFirst * waysThird) % MOD;
        }
        // 前半部分 A[1..n]的方案数为 C(m+n-1, n)
        long long countA = C(m + n - 1, n);
        ans = countA * sumB % MOD;
    }
    // 情况3：一个地标在前半部分，一个在后半部分，即 x <= n < y
    else{
        int posB = y - n; // 地标在后半部分 B 中的位置
        long long total = 0;
        // 前半部分 A：要求 A[x] = h，
        // - A[1..(x-1)]：取值在 [1,h]，方案数 C(h+x-2, x-1)
        // - A[x] 固定为 h
        // - A[(x+1)..n]：取值在 [h,m]，方案数 C(m-h+n-x, n-x)
        // 后半部分 B：要求 B[posB] = h，
        // - B[1..(posB-1)]：取值在 [h,m]（转化后方案数 C(m-h+posB-1, posB-1)）
        // - B[posB] 固定为 h
        // - B[(posB+1)..n]：取值在 [1,h]（转化后方案数 C(h+n-posB-1, n-posB)）
        for (int h = 1; h <= m; h++){
            long long waysA = C(h + x - 2, x - 1) * C(m - h + n - x, n - x) % MOD;
            long long waysB = C(m - h + posB - 1, posB - 1) * C(h + n - posB - 1, n - posB) % MOD;
            total = (total + waysA * waysB) % MOD;
        }
        ans = total;
    }

    cout << ans % MOD << "\n";
    return 0;
}