#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp> 
#include <ext/pb_ds/tree_policy.hpp> 
using namespace __gnu_pbds;
using namespace std;
typedef tree<pair<int,int>,null_type,less<pair<int,int>>,rb_tree_tag,tree_order_statistics_node_update> oset;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
	*this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "
using ll = long long;
const int mod = 1e9 + 7;

/* There was a mistake in the calculation method of the reverse element, so it was corrected. I'm sorry. (7/24)
The upper left coordinates are (0, 0) and the lower right coordinates are (H-1, W-1).
For all i satisfying B ≤ i ≤ W, (0, 0),(H −A−1, i),(H −A, i),(H −1, W −1)
The number of routes that sequentially pass through is counted, and these are added together to find a route that is sufficient
Can be counted. Figure 1 illustrates this.
Based on the above idea, the number of routes that move downward y times and rightward x times is calculated.
It needs to be found efficiently, which is equal to C(x + y, x) (where C(n, r) is in n
Represents the number of combinations to choose from r).
C(n, r) = n!
Since r!(n−r)!, we have x!(mod 109 + 7) for 0 ≤ x ≤ H + W − 2.
(x!)−1
By multiplying (mod 109 + 7) by O(H + W) in advance and making a table, each
1
C(n, r) can be calculated by O(1). Since 109 + 7 is a prime number, the following can be said.
• x for all x that is not x ≡ 0 (mod 109 + 7)
-1
There is (mod 109 + 7).
• From Fermat's Little Theorem x
−1≡ x
It is 109+5 (mod 109+7).
Therefore, the inverse element (x!)−1≡ (x!)109+5(mod 109+7) of the factorial is converted to a suitable method such as the dichotomy.
It can be calculated in advance and obtained in advance. The order of dichotomy is O(1), but the constant multiple is 30
Note that there are twice as many. By the way, let M! be the maximum value of the factor to be calculated, and
After finding the inverse element (M!)−1 by the method of dichotomy, multiplying that number by M gives ((M − 1)!)−1,
Multiply that number by M − 1 to get ((M − 2)!)−1, and you can calculate as ....
You can build the inverse table faster, but this is not necessary this time.

(m + n-2)!/(n-1)!(m-1)!

*/

const int MAX = 3e5+5;
int fact[MAX];
int ans = 0;

int fastpow(int a, int b){
	int wynik = 1;
	while(b){
		if(b&1)wynik = ((ll)wynik*a)%mod;
		a = ((ll)a*a)%mod;
		b>>=1;
	}
	return wynik;
}

int binom(int a , int b){
	int licznik = fact[a];
	int mia = ((ll)fact[b] * fact[a-b])%mod;
	return ((ll)licznik*fastpow(mia,mod-2))%mod;
}

int ways(int x1 , int y1 , int x2 , int y2){
	return binom(x2-x1+y2-y1,x2-x1);
}

void test_case(){
	int n , m , a , b; cin >> n >> m >> a >> b;
	fact[0] = 1;
	for(int i = 1 ; i < MAX ; i++)
		fact[i] = ((ll)fact[i-1]*i)%mod;
	int licznik = 0;
	for(int i = n-a ; i>=1 ; i--){
		int x = i , y = b+1+licznik;
		if(y>m)
			break;
		ans = ((ll)ans+(ll)ways(1,1,x,y)*ways(x,y,n,m))%mod;
		licznik++;
	}
	cout<<ans;
}
 
int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);
	int T=1;
	//~ cin >> T;
	while(T--){
		test_case();
	}
	return 0;
}


Measured memory_bytes: 1408