// Original C++ solution (slower):
# include<bits/stdc++.h>

using namespace std;

# define lowbit(x) ((x)&(-x))

# define pi acos(-1.0)

# define eps 1e-8

# define MOD 1000000007

# define INF 1000000000

# define mem(a,b) memset(a,b,sizeof(a))

# define FOR(i,a,n) for(register int i=a; i<=n; ++i)

# define FDR(i,a,n) for(register int i=a; i>=n; --i)

# define AU(i,x)    for(auto i=x.begin(); i!=x.end(); ++i)

# define ALL(A) A.begin(),A.end()

# define bug puts("H");

# define lch p<<1,l,mid

# define rch p<<1|1,mid+1,r

# define mp make_pair

# define pb push_back

typedef pair<int,int> PII;

typedef vector<int> VI;

# pragma comment(linker, "/STACK:1024000000,1024000000")

typedef long long LL;

inline char nc(){

    static char buf[1000000],*p1=buf,*p2=buf;

    return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;

}

inline int Scan(){

    char ch=nc();int sum=0, f=1;

    if (ch=='-') f=-1, ch=nc();

    while(!(ch>='0'&&ch<='9'))ch=nc();

    while(ch>='0'&&ch<='9')sum=sum*10+ch-48,ch=nc();

    return sum*f;

}

int ps4[4][2]={0,1,0,-1,1,0,-1,0};

int ps8[8][2]={0,1,0,-1,1,0,-1,0,1,1,1,-1,-1,-1,-1,1};

inline int min(int a,int b,int c) {return min(a,min(b,c));}

inline int max(int a,int b,int c) {return max(a,max(b,c));}

inline int min(int a,int b,int c,int d){return min(min(a,b,c),d);}

inline int max(int a,int b,int c,int d){return max(max(a,b,c),d);}

//struct Edge{int p, next, w;}edge[maxn];

//inline add_edge(int u, int v, int w){edge[cnt]=Edge{v,head[u],w}; head[u]=cnt++;}

const int N=200005;

///Code begin..................................................................



LL A[N];



LL pow_mod(LL a, LL n, LL mod){

    LL ret=1, tmp=a%mod;

    while (n) {

        if (n&1) ret=ret*tmp%MOD;

        tmp=tmp*tmp%MOD;

        n>>=1;

    }

    return ret;

}

LL inv(LL a, LL mod){return pow_mod(a,mod-2,mod);}

void init(){

    A[0]=1; FOR(i,1,N-1) A[i]=A[i-1]*i%MOD;

}

LL C(int x, int y){

    return A[y]*inv(A[x]*A[y-x]%MOD,MOD)%MOD;

}

int main ()

{

    init();

    int H, W, A, B;

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

    LL ans=0;

    FOR(i,1,W-B) ans+=C(H-A-1,B+H-A+i-2)*C(A-1,A+W-B-i-1)%MOD;

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

    return 0;

}


// Optimized solution to the same problem (faster):
// #pragma GCC optimize("Ofast,O3,unroll-loops")

// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")



#include <vector>

#include <list>

#include <map>

#include <set>

#include <deque>

#include <queue>

#include <stack>

#include <bitset>

#include <algorithm>

#include <functional>

#include <numeric>

#include <utility>

#include <iostream>

#include <sstream>

#include <iomanip>

#include <cstdio>

#include <cmath>

#include <cstdlib>

#include <cctype>

#include <string>

#include <cstring>

#include <cstdio>

#include <cmath>

#include <cstdlib>

#include <ctime>

#include <climits>

#include <complex>

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>



using namespace __gnu_pbds;

using namespace std;



#define endl '\n'

#define hoise cerr<<"hoise - "<<__LINE__<<"\n"

#define tham getchar()

#define set0(ar) memset(ar, 0, sizeof ar)

#define setinf(ar) memset(ar, 126, sizeof ar)

#define vsort(v) sort(v.begin(), v.end())

#define all(x) (x).begin(), (x).end()

#define FASTIO ios::sync_with_stdio(false);cin.tie(nullptr);



using ll = long long;

using pii = pair <int, int>;

using pll = pair <ll, ll>;

using vi = vector <int>;

using vl = vector <ll>;

using vpii = vector < pii >;

using vpll = vector < pll >;



const int MXN = (int)2e5+6;

const double PI = acos(-1.0);

const ll MOD = 1e9 + 7;

const int INF = 1e9;

const double EPS = 1e-6;

const int dx[4] = {1,0,-1,0}, dy[4] = {0,1,0,-1};



#define error(args...) { string _s = #args; replace(_s.begin(), _s.end(), ',', ' '); stringstream _ss(_s); istream_iterator<string> _it(_ss); err(_it, args); }

void err(istream_iterator<string> it) {}

template<typename T, typename... Args>

void err(istream_iterator<string> it, T a, Args... args) {

    cerr << *it << " = " << a << endl;

    err(++it, args...);

}



int flipBit (int mask, int k) { return mask = mask ^ (1 << k); }

bool checkBit (int mask, int k) { return (mask >> k) & 1; }

int setBit (int mask, int k) { return mask = mask | (1 << k); }

int resetBit (int mask, int k) { if (checkBit (mask, k)) { mask = flipBit (mask, k); } return mask; }



inline void normal(ll &a) { a %= MOD; (a < 0) && (a += MOD); }

inline ll modMul(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a * b) % MOD; }

inline ll modAdd(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); return (a + b) % MOD; }

inline ll modSub(ll a, ll b) { a %= MOD, b %= MOD; normal(a), normal(b); a -= b; normal(a); return a; }

inline ll modPow(ll b, ll p) { ll r = 1; while (p) { if (p & 1) r = modMul(r, b); b = modMul(b, b); p >>= 1; } return r; }

inline ll modInverse(ll a) { return modPow(a, MOD - 2); }

inline ll modDiv(ll a, ll b) { return modMul(a, modInverse(b)); }



template <typename T> using orderedSet = tree<T, null_type, greater<T>, rb_tree_tag, tree_order_statistics_node_update>;

template <typename T> using orderedSet1 = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;



bool approximatelyEqual(float a, float b, float epsilon) {

    return fabs(a - b) <= ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);

}

bool essentiallyEqual(float a, float b, float epsilon) {

    return fabs(a - b) <= ( (fabs(a) > fabs(b) ? fabs(b) : fabs(a)) * epsilon);

}

bool definitelyGreaterThan(float a, float b, float epsilon) {

    return (a - b) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);

}

bool definitelyLessThan(float a, float b, float epsilon) {

    return (b - a) > ( (fabs(a) < fabs(b) ? fabs(b) : fabs(a)) * epsilon);

}



/*--------------------------------------------------------------------------------------------------------------------------*/



ll fact[MXN], inv[MXN];



ll ncr (ll n, ll r) {

	return (fact[n] % MOD * inv[n - r] % MOD * inv[r] % MOD) % MOD;

}



void solve () {

	

	ll h, w, a, b;

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

	

	fact[0] = 1;

	for (int i = 1; i <= h + w; ++i) {

		fact[i] = fact[i - 1] * i;

		fact[i] %= MOD;

	}

	

	for (int i = 0; i <= h + w; ++i) {

		inv[i] = modInverse (fact[i]);

		inv[i] %= MOD;

	}

	

	ll ans = 0;

	

	for (int i = b; i < w; ++i) {

		ll comb1 = ncr (h + i - a - 1, i);

		ll comb2 = ncr (w + a - i - 2, a - 1);

		ans += comb1 * comb2;

		ans %= MOD;

	}

	cout << ans << endl;

}



int main(){

	// FASTIO

	

	int t;

	// cin >> t;

	t = 1;

	

	while (t--) {

		solve ();

	}

	

    return 0;

}



/*

 * be careful before submitting in Lightoj, SPOJ, UVA

*/


// Fastest known solution for this problem: