// Original C++ solution (slower):
#include<cstdio>

#include<cstring>

#include<vector>

#include<queue>

#include<stack>

#include<algorithm>

#include<cmath>

#include<climits>

#include<string>

#include<set>

#include<numeric>

#include<map>

#include<iostream>

using namespace std;

#define rep(i,n) for(int i = 0;i<((int)(n));i++)

#define reg(i,a,b) for(int i = ((int)(a));i<=((int)(b));i++)

#define irep(i,n) for(int i = ((int)(n)-1);i>=0;i--)

#define ireg(i,a,b) for(int i = ((int)(b));i>=((int)(a));i--)

typedef long long ll;

typedef pair<ll, ll> mp;

ll mod = 1e9+7;

//LLONG_MIN



//WA



ll test(ll a,ll n){

	ll ans=1;

	while(n>0){

		if(n&1)ans=(ans*a)%mod;

		a=(a*a)%mod;

		n>>=1;

	}

	return ans;

}



int main(void){

	int H,W,A,B;

	ll fact[200010]={},inv[200010]={},ans=0;

	scanf("%d%d%d%d",&H,&W,&A,&B);

	fact[0]=1;

	reg(i,1,H+W)fact[i]=(fact[i-1]*i)%mod;

	inv[H+W] = test(fact[H+W],mod-2);

	ireg(i,0,H+W-1)inv[i]=(inv[i+1]*(i+1))%mod;

	reg(i,1,H-A){

		//C(B+i,i)*C((H-B)+(W-i+1),H-B)

		ll a;

		a = (fact[B+i-2]*inv[i-1])%mod;

		a = (a*inv[B-1])%mod;

		a = (a*fact[(W-(B+1))+(H-i)])%mod;

		a = (a*inv[W-(B+1)])%mod;

		a = (a*inv[H-i])%mod;

		ans = (ans+a)%mod;

	}

	// reg(i,1,W+H)printf("fact[%d]:%lld\n",i,fact[i]);

	// reg(i,1,W+H)printf("inv[%d]:%lld\n",i,inv[i]);

	printf("%lld\n",ans);

	return 0;

}

// Optimized solution to the same problem (faster):
#include<bits/stdc++.h>

using namespace std;

typedef long long ll;

#define rep(i,n) for(ll i = 0;i<((ll)(n));i++)

#define reg(i,a,b) for(ll i = ((ll)(a));i<=((ll)(b));i++)

#define irep(i,n) for(ll i = ((ll)(n)-1);i>=0;i--)

#define ireg(i,a,b) for(ll i = ((ll)(b));i>=((ll)(a));i--)

template<class T = int> using V = vector<T>;

template<class T = int> using VV = V< V<T> >;

template<class T = int> void print(vector<T> v){for(auto a:v)cout<<a<<" ";cout<<endl;}



/*

*/



template<int MOD>

struct ModInt {

	static const int Mod = MOD;

	unsigned x;

	ModInt() : x(0) { }

	ModInt(signed sig) { int sigt = sig % MOD; if (sigt < 0) sigt += MOD; x = sigt; }

	ModInt(signed long long sig) { int sigt = sig % MOD; if (sigt < 0) sigt += MOD; x = sigt; }

	int get() const { return (int)x; }



	ModInt &operator+=(ModInt that) { if ((x += that.x) >= MOD) x -= MOD; return *this; }

	ModInt &operator-=(ModInt that) { if ((x += MOD - that.x) >= MOD) x -= MOD; return *this; }

	ModInt &operator*=(ModInt that) { x = (unsigned long long)x * that.x % MOD; return *this; }

	ModInt &operator/=(ModInt that) { return *this *= that.inverse(); }



	ModInt operator+(ModInt that) const { return ModInt(*this) += that; }

	ModInt operator-(ModInt that) const { return ModInt(*this) -= that; }

	ModInt operator*(ModInt that) const { return ModInt(*this) *= that; }

	ModInt operator/(ModInt that) const { return ModInt(*this) /= that; }



	ModInt inverse() const {

		signed a = x, b = MOD, u = 1, v = 0;

		while (b) {

			signed t = a / b;

			a -= t * b; std::swap(a, b);

			u -= t * v; std::swap(u, v);

		}

		if (u < 0) u += Mod;

		ModInt res; res.x = (unsigned)u;

		return res;

	}

};

typedef ModInt<1000000007> mint;

mint modpow(ll _a, ll n) {

 	mint r=1,a=_a;

 	while(n){

 		r*=((n%2)?a:1);

 		a*=a;

 		n>>=1;

 	}

 	return r;

 }

vector<mint> fact, factinv;

void nCr_computeFactinv(int N) {

	N = min(N, mint::Mod - 1);

	fact.resize(N + 1); factinv.resize(N + 1);

	fact[0] = 1;

	reg(i, 1, N) fact[i] = fact[i - 1] * i;

	factinv[N] = fact[N].inverse();

	for (int i = N; i >= 1; i --) factinv[i - 1] = factinv[i] * i;

}

mint nCr(int n, int r) {

	if (n >= mint::Mod)

		return nCr(n % mint::Mod, r % mint::Mod) * nCr(n / mint::Mod, r / mint::Mod);

	return r > n ? 0 : fact[n] * factinv[n - r] * factinv[r];

}

mint nPr(int n, int r) {

	if (r<0)return 0;

	return r > n ? 0 : fact[n] * factinv[n-r];

}

mint nHr(int n, int r) { return r == 0 ? 1 : nCr(n + r - 1, r); }



int h,w,a,b;

mint ans=0;



int main(void){

	cin>>h>>w>>a>>b;

	nCr_computeFactinv(h+w);

	reg(i,b+1,w)ans += nCr(h - a + i - 2 , i - 1) * nCr(a - 1 + w - i , a - 1);

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

	return 0;

}

// Fastest known solution for this problem: