//負数の合同も考慮に入れるmod関数
inline long long imod(long long a, long long b)
{
	return (a >= 0) ? (a % b) : (a % b + b);
}

//mintが引数の繰り返し2乗法
class mint;
mint pow(mint x, long long n);

//modの整数クラス
class mint
{
public:
	static void set_mod(long long m_)
	{
		//無効な値は無視
		if (m_ < 2)return;
		//modの値を更新
		mod = m_;
		//オイラー関数Φ(mod)を計算する
		e_phi = m_;
		for (int i = 2; i * i <= m_; ++i)
		{
			if (m_ % i == 0)
			{
				e_phi = e_phi / i * (i - 1);
				for (; m_ % i == 0; m_ /= i);
			}
		}
		if (m_ != 1)e_phi = e_phi / m_ * (m_ - 1);
	}
	mint operator+(const mint &other)const
	{
		return mint(imod(value + other.value, mod));
	}
	mint operator-(const mint &other)const
	{
		return mint(imod(value - other.value, mod));
	}
	mint operator*(const mint &other)const
	{
		return mint(imod(value * other.value, mod));
	}
	mint operator+=(const mint &other)
	{
		value = imod(value + other.value, mod);
		return mint(value);
	}
	mint operator-=(const mint &other)
	{
		value = imod(value - other.value, mod);
		return mint(value);
	}
	mint operator*=(const mint &other)
	{
		value = imod(value * other.value, mod);
		return mint(value);
	}
	mint operator+()const
	{
		return *this;
	}
	mint operator-()const
	{
		return mint(-value);
	}
	mint& operator++()
	{
		*this += 1;
		return *this;
	}
	mint operator++(int)
	{
		auto tmp = *this;
		*this += 1;
		return tmp;
	}
	mint& operator--()
	{
		*this -= 1;
		return *this;
	}
	mint operator--(int)
	{
		auto tmp = *this;
		*this -= 1;
		return tmp;
	}
	mint operator~()const
	{
		return pow(value, e_phi - 1);
	}
	mint& operator=(const mint &other)
	{
		value = other.value;
		return *this;
	}
	operator long long()const
	{
		return value;
	}
	static long long getmod()
	{
		return mod;
	}
	mint(long long a_) :value(imod(a_, mod)) {}
	mint() :value(0) {}
private:
	static long long mod;
	static long long e_phi;
	long long value;
};

//mintの累乗
//x^nを計算します
mint pow(mint x, long long n)
{
	mint res = 1;
	while (n > 0)
	{
		if (n & 1)res *= x;
		x *= x;
		n >>= 1;
	}
	return res;
}

#include <vector>

//mintの階乗計算
//O(x)程度の時間がかかります
//非推奨、同時間でfact_setが計算可能
mint fact(mint x)
{
	mint res(1);
	for (long long i = 1; i <= (long long)x; ++i)
	{
		res *= i;
	}
	return res;
}

//mintの階乗計算のリスト
//setの末尾に0～xまでの階乗数の列挙をします
//O(x)程度の時間がかかります
void fact_set(std::vector<mint> &set, mint x = mint(-1))
{
	mint res(1);
	set.push_back(1);
	for (long long i = 1; i <= (long long)x; ++i)
	{
		res *= i;
		set.push_back(res);
	}
}

long long mint::mod = 1000000000 + 7;
long long mint::e_phi = mod - 1;

#include<iostream>

//mint型のstreamへの入出力対応
std::ostream& operator<<(std::ostream& os, mint i)
{
	os << (long long)i;
	return os;
}

std::istream& operator >> (std::istream& is, mint& i)
{
	long long tmp;
	is >> tmp;
	i = tmp;
	return is;
}

mint h, w, a, b;
std::vector<mint> facts;

//nのうちr個を選ぶ通り数
inline mint combination(mint n, mint r)
{
	return facts[n] * ~facts[n - r] * ~facts[r];
}

int main()
{
	std::cin >> h >> w >> a >> b;
	fact_set(facts, h + w);
	mint ans;
	for (long long k = b; k < w; ++k)
	{
		ans += combination(k + h - a - mint(1), h - a - mint(1)) * combination(-k + w + a - 2,a - mint(1));
	}
	std::cout << ans << std::endl;
	return 0;
}

Measured memory_bytes: 2420