//#include "stdafx.h"
#include <iostream>
#include <set>
#include <queue>
#include <vector>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <string>
#include <cstring>
#include <climits>
#include <sstream>
#include <iomanip>
#include <map>
#include <stack>
#include <tuple>
#include <numeric>
#include <assert.h>
#include <functional>
#include <unordered_map>
#include <cstdint>

using namespace std;

/*-----------------------------------------------------------------------------
　定義
 -------------------------------------------------------------------------------*/
#define REP(i, n)				for (int (i) = 0 ; (i) < (int)(n) ; ++(i))
#define REPN(i, m, n)			for (int (i) = m ; (i) < (int)(n) ; ++(i))
#define INF						2e9
#define MOD						(1000 * 1000 * 1000 + 7)
#define Ceil(x, n)				(((((x))+((n)-1))/n))		/* Nの倍数に切り上げ割り算 */
#define CeilN(x, n)				(((((x))+((n)-1))/n)*n)		/* Nの倍数に切り上げ */
#define FloorN(x, n)			((x)-(x)%(n))				/* Nの倍数に切り下げ */
#define IsOdd(x)				(((x)&0x01UL) == 0x01UL)			
#define IsEven(x)				(!IsOdd((x)))						
#define	BitSetV(Val,Bit)		((Val) |= (Bit))			
#define	BitTstV(Val,Bit)		((Val) & (Bit))				
#define ArrayLength(x)			(sizeof( x ) / sizeof( x[ 0 ]))
#define	MAX_QWORD				((QWORD)0xFFFFFFFFFFFFFFFF)
#define M_PI					3.14159265358979323846
typedef long long				ll;
typedef unsigned long long int	QWORD;
typedef unsigned long long		SQWORD;
typedef pair<ll, ll>			P;

/*-----------------------------------------------------------------------------
　処理
 -------------------------------------------------------------------------------*/
/**
 *  mod による操作ライブラリ
 */
#define ANS_MOD (1000000007)
class MODINT {
    static SQWORD sqMod;
    SQWORD m_x;

public:
    MODINT(SQWORD val) {
        m_x = (val % sqMod + sqMod) % sqMod;
    };
    MODINT() {
        m_x = 0;
    }
    static void Init(SQWORD sqMod) {
        sqMod = sqMod;
    }

	MODINT& operator+= (const MODINT a)
    {
        m_x = (m_x + a.m_x) % sqMod; 
        return *this;
    };
	MODINT& operator-= (const MODINT a)
    { 
        m_x = (m_x - a.m_x + sqMod) % sqMod; 
        return *this;
    };
	MODINT& operator*= (const MODINT a)
    {
        m_x = (m_x * a.m_x) % sqMod;
        return *this;
    };
    MODINT pow(SQWORD t) const {
        if (!t) return 1;
        MODINT a = pow(t>>1);
        a *= a;
        if (t&1) a *= *this;
        return a;
    }
	MODINT operator+ (const MODINT a) const {
		MODINT res(*this);
		return (res += a);
	}
	MODINT operator- (const MODINT a) const {
		MODINT res(*this);
		return (res -= a);
	}
	MODINT operator* (const MODINT a) const {
		MODINT res(*this);
		return (res *= a);
	}
	MODINT operator/ (const MODINT a) const {
		MODINT res(*this);
		return (res /= a);
	}

    /* 逆元 */
    MODINT inv() const {
        return pow(sqMod-2);
    }

    /* 除算 */
    MODINT& operator/=(const MODINT a) {
        return (*this) *= a.inv();
    } 

    /* 整数版 */
	MODINT& operator+= (const SQWORD a) {*this += MODINT(a); return *this;};
	MODINT& operator-= (const SQWORD a) {*this -= MODINT(a); return *this;};
	MODINT& operator*= (const SQWORD a) {*this *= MODINT(a); return *this;};
	MODINT& operator/= (const SQWORD a) {*this /= MODINT(a); return *this;};

    SQWORD getVal() { return m_x; };
};
SQWORD MODINT::sqMod = ANS_MOD;


// テーブルを作る前処理
const int MAX = 2 * 1000 * 1000;
long long fac[MAX], finv[MAX], inv[MAX];
void CombInit() 
{
    fac[0] = fac[1] = 1;
    finv[0] = finv[1] = 1;
    inv[1] = 1;
    for (int i = 2; i < MAX; i++){
        fac[i] = fac[i - 1] * i % MOD;
        inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
        finv[i] = finv[i - 1] * inv[i] % MOD;
    }
}

// 二項係数計算(nCk)
long long CombExec(int n, int k)
{
    if (n < k) return 0;
    if (n < 0 || k < 0) return 0;
    return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}

int main()
{
	int H, W, A, B;
	cin >> H >> W >> A >> B;
	
	CombInit();

	// 全部いけるマス
	// (i+j) Comb (j)
	int i;
	int allMasH = H - A - 1;
	vector<MODINT> allCmb(W, 0);
	for (i = 0; i < W; i++) {
		allCmb[i] = CombExec(i + allMasH, i);
	}
	
	// 一部いけるマス
/*	int partMasH = A;	// 境界の一つ手前も含む
	vector<MODINT> partCmb(W, 0);
	for (i = 0; i < W - B; i++) {
		partCmb[i + B] = CombExec(i + partMasH, i);
	}

	for (i = B; i < W; i++) {
		ans += allCmb[i] * partCmb[i];
	}
	MODINT ans = 0;
	for (i = B; i < W; i++) {
		ans += allCmb[i] * partCmb[i];
	}*/

	// 一部いけるマス
	MODINT ans = 0;
	int partMasH = A - 1;
	for (i = B; i < W; i++) {
		int nokoriX = W - i - 1;
		MODINT partCmbRes = CombExec(nokoriX + partMasH, nokoriX);
		ans += allCmb[i] * partCmbRes;
	}


	cout << ans.getVal() << endl;

/*	dp[0] = 1;
	REP(i, H) {
		int startPos = (i < H - A) ? 0 : B;
		REPN(j, startPos, W - 1) {
			MODINT updVal = dp[j + 1] + dp[j];
			dp[j + 1] = max(dp[j + 1].getVal(), updVal.getVal());
		}
	}
	cout << dp[W - 1].getVal() << endl;*/
	return 0;
}


Measured memory_bytes: 47872