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



#define ft first

#define sd second

#define sz(x) ((int)x.size())



using namespace std;



typedef long long ll;

typedef pair<int, int> pii;

typedef pair<ll, ll> pll;



const int D = 1000 * 1000 * 1000 + 7, MAXN = 2 * 100 * 1000 + 123;





void multi(int& x, int y) { x = (ll)x * y % D; }

int inv(int x) {

	int res = 1;

	for (int i = D - 2; i; i >>= 1, x = (ll)x * x % D)

		if (i & 1)

			res = (ll)res * x % D;

	return res;

}



int r, c, a, b, ans, jav, fact[MAXN];





int main() {

	fact[0] = 1;

	for (int i = 1; i < MAXN; i++)

		fact[i] = (ll)fact[i - 1] * i % D;

	cin >> r >> c >> a >> b;

	for (int i = 0; i < r - a; i++) {

		jav = fact[b + i - 1];

		multi(jav, inv(fact[b - 1]));

		multi(jav, inv(fact[i]));

		multi(jav, fact[r - i + c - b - 2]);

		multi(jav, inv(fact[r - i - 1]));

		multi(jav, inv(fact[c - b - 1]));

		ans += jav;

		ans %= D;

	}

	cout << ans;

	return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <algorithm>

#include <vector>

#define repeat(n) for (size_t i = 0; i < n; i++)

#define ull unsigned long long

#define vll vector<ull>

constexpr ull MOD = 10e8+7;



using namespace std;



ull mod_saberi(ull x, ull y)

{

	return (x % MOD + y % MOD) % MOD;

}

ull mod_pomnozi(ull x, ull y)

{

	return ((x % MOD) * (y % MOD)) % MOD;

}

bool je_paran(ull broj) { return !(broj & 1); }

ull brzo_stepenuj(ull osnova, ull exponent)

{

	if (exponent == 0)

		return 1;

	if (je_paran(exponent))

	{

		ull exp_pola = brzo_stepenuj(osnova, exponent / 2);

		return mod_pomnozi(exp_pola, exp_pola);

	}

	else

	{

		ull ostatak = osnova;

		ull exp_pola = brzo_stepenuj(osnova, (exponent - 1) / 2);

		return mod_pomnozi(ostatak, mod_pomnozi(exp_pola, exp_pola));

	}

}

ull n_choose_k(ull n_faktorijel, ull k_faktorijel, ull nk_faktorijel)

{

	return mod_pomnozi(n_faktorijel, brzo_stepenuj(mod_pomnozi(k_faktorijel, nk_faktorijel), MOD - 2));

}



vll broj_nacina_do_polja(ull polja_horizontalno, ull polja_vertikalno, int broj_polja)

{

	vll broj_nacina = vll(broj_polja);

	ull n_faktorijel = 1, k_faktorijel = 1, nk_faktorijel = 1;

	for (ull i = 1; i <= polja_horizontalno + polja_vertikalno; i++)

	{

		n_faktorijel = mod_pomnozi(n_faktorijel, i);

		if (i == (polja_vertikalno))

			nk_faktorijel = n_faktorijel;

		if (i == polja_horizontalno)

			k_faktorijel = n_faktorijel;

	}



	for (size_t i = 1; i <= broj_polja; i++)

	{

		broj_nacina[i - 1] = n_choose_k(n_faktorijel, k_faktorijel, nk_faktorijel);

		n_faktorijel = mod_pomnozi(n_faktorijel, polja_horizontalno + polja_vertikalno + i);

		nk_faktorijel = mod_pomnozi(nk_faktorijel, polja_vertikalno + i);

	}

	return broj_nacina;

}

int main()

{

	ios::sync_with_stdio(false);

	cin.tie(0);

	int H, W, A, B;

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

	vll broj_nacina_desno = broj_nacina_do_polja(W - B - 1, A, H - A);

	reverse(broj_nacina_desno.begin(), broj_nacina_desno.end());

	vll broj_nacina_levo = broj_nacina_do_polja(B - 1, 0, H - A);

	ull ukupno_nacina = 0;

	for (size_t i = 0; i < broj_nacina_levo.size(); i++)

	{

		ukupno_nacina = mod_saberi(ukupno_nacina, mod_pomnozi(broj_nacina_levo[i], broj_nacina_desno[i]));

	}

	cout << ukupno_nacina << "\n";

	return 0;

}

// Fastest known solution for this problem: