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

#include <iomanip>

#include <cstdio>

#include <string>

#include <cstring>

#include <deque>

#include <list>

#include <queue>

#include <stack>

#include <vector>

#include <utility>

#include <algorithm>

#include <map>

#include <set>

#include <complex>

#include <cmath>

#include <limits>

#include <cfloat>

#include <climits>

#include <ctime>

#include <cassert>

#include <numeric>

#include <functional>

using namespace std;



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

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

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

#define all(v) begin(v), end(v)

#define pb(a) push_back(a)

#define fr first

#define sc second

#define INF 2000000000

#define int long long int



#define X real()

#define Y imag()

#define EPS (1e-10)

#define EQ(a,b) (abs((a) - (b)) < EPS)

#define EQV(a,b) ( EQ((a).X, (b).X) && EQ((a).Y, (b).Y) )

#define LE(n, m) ((n) < (m) + EPS)

#define LEQ(n, m) ((n) <= (m) + EPS)

#define GE(n, m) ((n) + EPS > (m))

#define GEQ(n, m) ((n) + EPS >= (m))



typedef vector<int> VI;

typedef vector<VI> MAT;

typedef pair<int, int> pii;

typedef long long ll;



typedef complex<double> P;

typedef pair<P, P> L;

typedef pair<P, double> C;



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

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

int const MOD = 1000000007;



// ModInt begin



ll mod_pow(ll x, ll n) {return (!n)?1:(mod_pow((x*x)%MOD,n/2)*((n&1)?x:1))%MOD;}

struct ModInt {

    ll v;

    ModInt(ll a = 0) : v(((a%MOD) + MOD) % MOD) {}

    ModInt  operator+ ( const ModInt& b ) const {return (v + b.v) % MOD;}

    ModInt  operator- ( const ModInt& b ) const {return (v - b.v + MOD) % MOD;}

    ModInt  operator* ( const ModInt& b ) const {return (v * b.v) % MOD;}

    ModInt  operator/ ( const ModInt& b ) const {return (v * mod_pow(b.v, MOD-2)) % MOD;}

};



bool    operator==(ModInt  a, ModInt b) {return a.v == b.v;}

ModInt& operator+=(ModInt& a, ModInt b) {return a = a + b;}

ModInt& operator-=(ModInt& a, ModInt b) {return a = a - b;}

ModInt& operator*=(ModInt& a, ModInt b) {return a = a * b;}

ModInt& operator/=(ModInt& a, ModInt b) {return a = a / b;}

ostream& operator<<(ostream& out, ModInt  a) {return out << a.v;}

istream& operator>>(istream& in,  ModInt& a) {

    ll v; in >> v;

    a = ModInt(v);

    return in;

}



// ModInt end



ModInt fact[200010];



ll comb(int n, int r) {

    if(n < r) return 0;

    ModInt ret = fact[n];

    ret /= fact[n-r];

    ret /= fact[r];

    return ret.v;

}



signed main() {

    fact[0] = 1;

    rep(i,1,200010) fact[i] = fact[i-1] * i;



    int h, w, a, b; cin >> h >> w >> a >> b;

    ModInt ans = 0;

    repq(i,1,w-b) {

        ModInt va = comb(h-a+b+i-2, b+i-1);

        ModInt vb = comb(w-b-i+1+a-2, a-1);

        ans += va * vb;

    }

    cout << ans << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
// 基本テンプレート



#include <iostream>

#include <iomanip>

#include <cstdio>

#include <string>

#include <cstring>

#include <deque>

#include <list>

#include <queue>

#include <stack>

#include <vector>

#include <utility>

#include <algorithm>

#include <map>

#include <set>

#include <complex>

#include <cmath>

#include <limits>

#include <cfloat>

#include <climits>

#include <ctime>

#include <cassert>

#include <numeric>

#include <functional>

using namespace std;



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

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

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

#define int long long int



template<typename T> void chmax(T &a, T b) {a = max(a, b);}

template<typename T> void chmin(T &a, T b) {a = min(a, b);}

template<typename T> void chadd(T &a, T b) {a = a + b;}



typedef pair<int, int> pii;

typedef long long ll;



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

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

constexpr ll INF = 1001001001001001LL;

constexpr ll MOD = 1000000007LL;



int fact[200010];

int H, W, A, B;



ll mod_pow(ll x, ll n) {return (!n)?1:(mod_pow((x*x)%MOD,n/2)*((n&1)?x:1))%MOD;}

// 組み合わせ nCr を求める (modあり)

ll combination_mod(ll n, ll r, ll mod) {

    if(r > n-r) r = n-r;

    if(r == 0) return 1;

    // printf("n = %lld, n-r = %lld, r = %lld\n", n, n-r, r);

    ll a = fact[n], b = fact[n-r], c = fact[r];

    ll ret = (a * mod_pow(b, MOD-2)) % MOD;

    (ret *= mod_pow(c, MOD-2)) %= MOD;

    return ret;

}



signed main() {

    cin >> H >> W >> A >> B;

    fact[0] = 1; rep(i,1,200010) fact[i] = (fact[i-1] * i) % MOD;



    int ans = 0;

    repq(i,B+1,W) {

        ll ra = combination_mod((H-A-1) + (i-1), (H-A-1), MOD);

        ll rb = combination_mod((A-1) + (W-i), (A-1), MOD);

        // printf("H-A = %lld, i = %lld, ra = %lld, rb = %lld\n", H-A, i, ra, rb);

        (ans += (ra * rb) % MOD) %= MOD;

    }

    cout << ans << endl;

    return 0;

}

// Fastest known solution for this problem: