Problem:
Score : 400 points

Problem Statement

We have a large square grid with H rows and W columns.
Iroha is now standing in the top-left cell.
She will repeat going right or down to the adjacent cell, until she reaches the bottom-right cell.

However, she cannot enter the cells in the intersection of the bottom A rows and the leftmost B columns. (That is, there are A×B forbidden cells.) There is no restriction on entering the other cells.

Find the number of ways she can travel to the bottom-right cell.

Since this number can be extremely large, print the number modulo 10^9+7.

Constraints

1 ≦ H, W ≦ 100,000

1 ≦ A < H

1 ≦ B < W

Input

The input is given from Standard Input in the following format:

H W A B

Output

Print the number of ways she can travel to the bottom-right cell, modulo 10^9+7.

Sample Input 1

2 3 1 1

Sample Output 1

2

We have a 2×3 grid, but entering the bottom-left cell is forbidden. The number of ways to travel is two: "Right, Right, Down" and "Right, Down, Right".

Sample Input 2

10 7 3 4

Sample Output 2

3570

There are 12 forbidden cells.

Sample Input 3

100000 100000 99999 99999

Sample Output 3

1

Sample Input 4

100000 100000 44444 55555

Sample Output 4

738162020

Solution in C++14 (GCC 5.4.1) (judge verdict: Accepted)

#include<bits/stdc++.h>
using namespace std;
 
#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define SORT(c) sort((c).begin(),(c).end())
#define IINF INT_MAX
#define LLINF LLONG_MAX
#define DEBUG false
 
typedef long long ll;
typedef pair<int, int> ii;

ll N = 200010;
ll MOD = 1000000007;
ll fac[200010], facInv[200010];
ll inv[200010];
ll ans[100000];

int main(){

	fac[0] = facInv[0] = inv[1] = 1;
	for (int i = 2; i <= N; ++i)
		inv[i] = MOD - (MOD / i) * inv[MOD % i] % MOD;

	for (int i = 1; i <= N; ++i) {
		fac[i] = (fac[i - 1] * i) % MOD;
		facInv[i] = (facInv[i - 1] * inv[i]) % MOD;
	}
	
	ll h, w, a, b;
	cin >> h >> w >> a >> b;
	
	ll res = 0;
	ll sum1 = h - a - 1 + b;
	ll sum2 = w - b - 1 + a;
	for(int i = 0; i < min(h-a, w-b); i++){
		ans[i] = fac[sum1];
		ans[i] = (ans[i] * facInv[h - a - 1 - i]) % MOD;
		ans[i] = (ans[i] * facInv[b + i]) % MOD;
		ans[i] = (ans[i] * fac[sum2]) % MOD;
		ans[i] = (ans[i] * facInv[a + i] % MOD);
		ans[i] = (ans[i] * facInv[w - b - 1 - i]) % MOD;
		res = (res +ans[i]) % MOD;
	}
	
	cout << res << endl;
 
	return 0;
}