stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<cmath>

#include<cstring>

#include<queue>

#include<stack>

#include<map>

#include<string>

#include<algorithm>

using namespace std;

#define inf 0x3f3f3f3f

#define ll long long



const ll mod = 1e9+7;

const int maxn = 200005;

ll f[maxn],inv[maxn];

int N;



ll Pow(ll a,ll b)

{

	ll ans=1;

	while(b){

		if(b&1) ans=(ans*a)%mod;

		a=(a*a)%mod;

		b>>=1;

	}

	return ans;

}



void init()

{

	f[0]=1;

	for(int i=1;i<=N;i++){

		f[i]=f[i-1]*i%mod;

	}

	inv[0]=1;

	inv[N]=Pow(f[N],mod-2);

	for(int i=N-1;i>0;i--){

		inv[i]=inv[i+1]*(i+1)%mod;

	}

}



ll C(int a,int b)

{

	if(a<0||b<0) return 1;

	return f[a]*inv[b]%mod*inv[a-b]%mod;

}



int main()

{

    ll n,m,a,b;

	scanf("%lld%lld%lld%lld",&n,&m,&a,&b);

	N=n+m-2;

	init();

	ll ans=C(n+m-2,n-1);

	for(ll i=1;i<=b;i++){

		ans-=C(n-a+i-2,n-a-1)*C(a-1+m-i,a-1);

		ans=(ans%mod+mod)%mod;

	}

	cout<<ans<<endl;

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 2.0406838268352145x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

long long mod=1000000000+7,n,m,h,w,jie[200003],ans;

long long mi(long long x,long long t)

{

	if(t==1)

		return x;

	long long sum=mi(x,t/2);

	sum=(sum*sum)%mod;

	if(t%2==1)

		sum=(sum*x)%mod;

	return sum;

}

long long c(long long n,long long m)

{

	return (mi((jie[n-m]*jie[m])%mod,mod-2)*jie[n])%mod;

}

int main()

{

	cin>>n>>m>>h>>w;

	jie[0]=1,jie[1]=1;

	for(long long i=2; i<=200000; i++)

		jie[i]=(jie[i-1]*i)%mod;

	for(long long i=1; h+i<=n&&w+i<=m; i++)

		ans=(ans+(c(n+w-h-1,w+i-1)*c(h+m-w-1,m-w-i)%mod))%mod;

	cout<<ans;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.3588606500430105x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include <iostream>

#include <cstdio>

#define int long long

#define N 200002

using namespace std;

const int mod=1000000007;

int a,b,x,y,i,j,f[N],inv[N];

int poww(int a,int b)

{

	int ans=1,base=a;

	while(b){

		if(b&1) ans=ans*base%mod;

		base=base*base%mod;

		b>>=1;

	}

	return ans;

}

int C(int n,int m)

{

	return f[n]*inv[m]%mod*inv[n-m]%mod;

}

signed main()

{

	cin>>a>>b>>x>>y;

	f[0]=1;

	for(i=1;i<=200000;i++) f[i]=f[i-1]*i%mod;

	inv[200000]=poww(f[200000],mod-2);

	for(i=199999;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;

	int ans=C(a+b-2,b-1);

	for(i=a-x+1;i<=a-x+1;i++){

		for(j=1;j<=y;j++) ans=(ans-C(i+j-3,j-1)*C(a+b-i-j,b-j)%mod+mod)%mod;

	}

	cout<<(ans+mod)%mod<<endl;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.850177722554024x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

typedef long long LL;

LL jc[300002];

LL quickmi(LL b,LL p,LL k)

{

	if(!p)return 1;

	LL ans=1,tmp=b;

	while(p)

	{

		if(p&1)ans=ans*tmp%k;

		tmp=tmp*tmp%k;

		p>>=1;

	}

	return ans%k;

}

LL C(LL n,LL m,LL k)

{

	if(n<m)return 0;

	return jc[n]*quickmi(jc[m]%k,k-2,k)%k*quickmi(jc[n-m]%k,k-2,k)%k;

}

LL Lucas(LL n,LL m,LL k)

{

	if(!m)return 1;

	return C(n%k,m%k,k)*Lucas(n/k,m/k,k)%k;

}

LL h,w,a,b,p;

LL ans;

int main()

{

	jc[0]=1;p=1e9+7;

	scanf("%lld%lld%lld%lld",&h,&w,&a,&b);

	if(h<w)

	{

		swap(h,w);

		swap(a,b);

	}

	for(LL i=1;i<=h+w;i++)jc[i]=jc[i-1]*i%p;

	if(Lucas(b-1,b-1,p)==0)

	{

		ans=(Lucas(w-b-1+h-1,w-b-1,p)+ans)%p;

	}

	for(int i=0;i<=h-a-1;i++)

	{

		ans=(ans+Lucas(b-1+i,b-1,p)*Lucas(w-b-1+h-1-i,w-b-1,p))%p;

	}

	printf("%lld\n",ans);

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 2.215127842065248x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include <cstdio>

#include <cstring>

using namespace std;

typedef long long ll;

ll n,m,a,b;

ll fpow(ll b,ll p,ll mod)

{

	ll ans=1,tmp=b;

	while(p)

	{

		if(p&1)ans=ans*tmp%mod;

		tmp=tmp*tmp%mod;

		p>>=1;

	}

	return ans%mod;

}

ll inv(ll b,ll mod)

{

	return fpow(b,mod-2,mod)%mod;

}

const int N=200002;

const ll mod=1e9+7;

ll fac[N],ans=0;

ll C(ll n,ll m)

{

	if(n<m)return 0;

	return fac[n]%mod*inv(fac[m],mod)%mod*inv(fac[n-m],mod)%mod;

}

ll Lucas(ll n,ll m)

{

	if(!m)return 1;

	return C(n%mod,m%mod)*Lucas(n/mod,m/mod);

}

int main()

{

	fac[0]=1;

	for(int i=1;i<=200000;i++)fac[i]=fac[i-1]*i%mod;

	scanf("%lld%lld%lld%lld",&n,&m,&a,&b);

	for(ll i=1;i<=n-a&&i<=m-b;i++)

	{

		ll X=n-a-i,Y=b+i-1;

		ans=(ans+Lucas(X+Y,X)%mod*Lucas(m-Y+n-X-2,m-Y-1)%mod)%mod;

	}

	printf("%lld\n",ans);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 3.0477756593125895x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include<iostream>

#include<cstdio>

#include<cmath>

#include<cstring>

using namespace std;



#define REP(i,e,s) for(register int i=e; i<=s; i++)

#define DREP(i,e,s) for(register int i=e; i>=s; i--)

#define ll long long

#define DE(...) fprintf(stderr,__VA_ARGS__)

#define DEBUG(a) DE("DEBUG: %d\n",a)



#define int long long



int read() {

	int x=0,f=1,ch=getchar();

	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}

	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}

	return x*f;

}

const int MOD=1e9+7,MAXN=200000+10;



int fac[MAXN],inv[MAXN];



int qpow(int a,int b) {

	int ans=1;

	while(b) {

		if(b&1) ans=(ans*a)%MOD;

		a=(a*a)%MOD;

		b>>=1;

	}

	return ans;

}



int c(int m,int n) {

	if(n==m||!m||!n) return 1;

	return ((fac[m]*inv[n]%MOD)*inv[m-n])%MOD;

}



int calc(int x_1,int y_1,int x_2,int y_2) {

	return c(abs(x_2-x_1)+abs(y_2-y_1),abs(x_2-x_1));

}



signed main() {

	int h=read(),w=read(),a=read(),b=read();

	fac[0]=1;

	REP(i,1,h+w) fac[i]=(fac[i-1]*i)%MOD;

	

	REP(i,1,h+w) inv[i]=qpow(fac[i],MOD-2);

	int ans=0;	

	REP(i,1,h-a) {

		ans=(ans+calc(1,1,b,i)*(calc(b+1,i,w,h)))%MOD;

	}

	

	printf("%lld\n",ans%MOD);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 5.161974324003384x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<algorithm>

#define LL long long

using namespace std;

const int mod=1e9+7,M=1e6+7;

LL read(){

	LL ans=0,f=1,c=getchar();

	while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}

	while(c>='0'&&c<='9'){ans=ans*10+(c-'0'); c=getchar();}

	return ans*f;

}

LL n,m,A,B;

LL qmod(LL a,LL b){

	LL ans=1;

	while(b){

		if(b&1) ans=ans*a%mod;

		b>>=1; a=a*a%mod;

	}

	return ans;

}

LL w[M],f[M];

void pre(){

	int mx=2e5; w[0]=1;

	for(int i=1;i<=mx;i++) w[i]=w[i-1]*i%mod;

	f[mx]=qmod(w[mx],mod-2);

	for(int i=mx;i>=1;i--) f[i-1]=f[i]*i%mod;

} 

LL C(LL n,LL m){return w[n]*f[n-m]%mod*f[m]%mod;}

LL F(int x,int y,int nx,int ny){

	int p=nx-x,q=ny-y;

	return C(p+q,q);

}

LL ans;

int main(){

	pre();

	n=read(); m=read(); A=read(); B=read();

	ans=F(1,1,n,m);

	for(int i=1;i<=B;i++){

		int sum=F(1,1,n-A,i)*F(n-A+1,i,n,m)%mod;

		ans=(ans-sum)%mod;

		ans=(ans+mod)%mod;

	}

	printf("%lld\n",ans);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.782249186368618x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include <bits/stdc++.h>

#include<ext/pb_ds/hash_policy.hpp>

#include<ext/pb_ds/assoc_container.hpp>

#define N 200005

using namespace __gnu_pbds;

const int mod = 1e9 + 7;

using namespace std;

typedef long long LL;

typedef unsigned long long uLL;

struct custom_hash {

    static uint64_t splitmix64(uint64_t x) {

        x += 0x9e3779b97f4a7c15;

        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;

        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;

        return x ^ (x >> 31);

    }

    size_t operator()(uint64_t x) const {

        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();

        return splitmix64(x + FIXED_RANDOM);

    }

};

LL z = 1;

int read(){

	int x, f = 1;

	char ch;

	while(ch = getchar(), ch < '0' || ch > '9') if(ch == '-') f = -1;

	x = ch - '0';

	while(ch = getchar(), ch >= '0' && ch <= '9') x = x * 10 + ch - 48;

	return x * f;

}

int ksm(int a, int b, int p){

	int s = 1;

	while(b){

		if(b & 1) s = z * s * a % p;

		a = z * a * a % p;

		b >>= 1;

	}

	return s;

}



int maxn = N - 5, fac[N], inv[N];

int C(int n, int m){

	return z * fac[n] * inv[m] % mod * inv[n - m] % mod; 

}

int main(){

	int i, j, a, b, n, m, c, d, ans, sum = 0;

	for(fac[0] = i = 1; i <= maxn; i++) fac[i] = z * fac[i - 1] * i % mod;

	inv[maxn] = ksm(fac[maxn], mod - 2, mod);

	for(i = maxn - 1; i >= 0; i--) inv[i] = z * inv[i + 1] * (i + 1) % mod;

	scanf("%d%d%d%d", &n, &m, &c, &d);

	ans = C(n + m - 2, n - 1);

	for(i = 1; i <= d; i++){

		a = n - c;

		b = i - 1;

		j = C(a + b, a);

		j = (j - sum) % mod;

		sum = (sum + j) % mod;

		j = z * j * C(c - 1 + m - i, c - 1) % mod;

		//printf("%d %d\n", i, j);

		ans = (ans - j) % mod;

	}

	ans = (ans + mod) % mod;

	printf("%d", ans);

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 5.030734292414221x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

typedef double db;

typedef long long ll;

typedef pair<int, int> pii;

#define fi first

#define se second

#define empb emplace_back

#define all(x) (x).begin(),(x).end()

#define lbd(a, x) lower_bound(all(a), x)

const int mod = 1e9 + 7;

int power_mod(int a, int b) {

	int res = 1;

	for(; b; b >>= 1, a = (ll) a * a % mod)

		if(b & 1) res = (ll) res * a % mod;

	return res;

}

const int N = 2e5 + 10;

int fac[N], ifac[N];

int C(int n, int m) {

	if(n < m || m < 0) return 0;

	return (ll) fac[n] * ifac[m] % mod * ifac[n - m] % mod;

}

int main() {

#ifdef local

	freopen("in.txt", "r", stdin);

#endif

	ios::sync_with_stdio(false);

	cin.tie(0), cout.tie(0);

  fac[0] = ifac[0] = 1;

  for(int i = 1; i < N; i++) fac[i] = (ll) fac[i - 1] * i % mod;

  ifac[N - 1] = power_mod(fac[N - 1], mod - 2);

  for(int i = N - 2; i; i--) ifac[i] = (ll) ifac[i + 1] * (i + 1) % mod;

  int n, m; cin >> n >> m;

  int a, b; cin >> a >> b;

  int res = C(n + m - 2, n - 1);

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

		res = (res - (ll) C(n - 1 - i + b - 1, b - 1) * C(m - b - 1 + i, i)) % mod;

  }

  if(res < 0) res += mod;

  cout << res << '\n';

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 4.562364159443761x):
#include<cstdio>

#include<algorithm>

using namespace std;

#define MOD 1000000007

#define MAXN 200005

#define LL long long

LL inv[MAXN],s[MAXN];

int N;

int n,m,x,y;

LL Pow(LL a,int b)

{

    LL ans=1;

    while(b)

	{

        if(b&1) ans=ans*a%MOD;

        a=a*a%MOD;

        b>>=1;

    }

    return ans;

}

void Pre()

{

    s[0]=1;

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

        s[i]=s[i-1]*i%MOD;

    inv[0]=1;

    inv[N]=Pow(s[N],MOD-2);

    for(int i=N-1; i>0; i--)

        inv[i]=inv[i+1]*(i+1)%MOD;

}

LL C(int a,int b)

{

    if(a<0||b<0) return 1;

    return s[a]*inv[b]%MOD*inv[a-b]%MOD;

}

int main()

{

 

    scanf("%d%d",&n,&m);

    scanf("%d%d",&x,&y);

    N=n+m-2;

    Pre();

    LL ans=0;

    for(int i=y+1;i<=m;i++)

    {

        ans+=C(n-x+i-2,i-1)*C(x+m-i-1,x-1)%MOD;

        ans%=MOD;

    }

    printf("%lld\n",ans);

}//
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



#define mp make_pair

#define pb push_back



typedef long long ll;

typedef pair<int, int> ii;

typedef pair<ll, ll> l4;





const int maxn = 2e5+1, mod = 1e9+7;

ll f[maxn], inv[maxn];

ll power(ll base, ll p)

{

  ll ret = 1;

  while (p)

    {

      if (p&1)

	ret = ret * base % mod;

      base = base * base % mod;

      p >>= 1;

    }

  return ret;

}

ll h, w, a, b;

ll cb(ll n, ll k)

{

  return f[n] * inv[k] % mod * inv[n-k] % mod;

}

inline void add(ll &a, ll b)

{

  a = a + b;

  if (a > mod)

    a %= mod;

}

int main()

{

  f[0] = 1;

  for (ll i = 1; i < maxn; ++i)

    f[i] = f[i-1] * i % mod;

  inv[maxn-1] = power(f[maxn-1], mod-2);

  for (ll i = maxn-1; i >= 1; --i)

    inv[i-1] = inv[i] * i % mod;

  scanf("%lld %lld %lld %lld", &h, &w, &a, &b);

  ll ret = 0;

  for (ll i = b+1; i <= w; ++i)

    add(ret, cb(h-a+i-2, h-a-1)*cb(a+w+1-i-2, a-1)%mod);

  printf("%lld\n", ret);

}


// Faster C++ solution for the same problem (measured speedup: 1.6663273748902532x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

const ll mod=1e9+7;

const int maxn=2e5+100;

ll fac[maxn],f[maxn];

ll fpow(ll x, ll c) { ll res = 1; for (; c > 0; c >>= 1) { if (c & 1) res = res * x % mod; x = x * x % mod; }return res; }



ll comb(ll x, ll y) {

	return fac[x] * fpow(fac[y] * fac[x - y] % mod, mod - 2) % mod;

}



void init(int n) { fac[0] = fac[1] = 1; for(int i=2;i<=n;i++) fac[i] = i * fac[i - 1] % mod; }

int main(){

	init(200010);

	int n,m,a,b;

	cin>>n>>m>>a>>b;

	int x=n-a,y=b+1;

	ll ans=0;

  while(x>=1&&y<=m){

		ans=(ans+comb(x+y-1-1,x-1)*comb(n+m-x-y,n-x))%mod;

		x--,y++;

	}

	cout<<ans<<'\n';

}
// Slower C++ solution:
#include<bits/stdc++.h>

using namespace std;

long long mod=1000000000+7,n,m,h,w,jie[200003],ans;

long long mi(long long x,long long t)

{

	if(t==1)

		return x;

	long long sum=mi(x,t/2);

	sum=(sum*sum)%mod;

	if(t%2==1)

		sum=(sum*x)%mod;

	return sum;

}

long long c(long long n,long long m)

{

	return (mi((jie[n-m]*jie[m])%mod,mod-2)*jie[n])%mod;

}

int main()

{

	cin>>n>>m>>h>>w;

	jie[0]=1,jie[1]=1;

	for(long long i=2; i<=200000; i++)

		jie[i]=(jie[i-1]*i)%mod;

	for(long long i=1; h+i<=n&&w+i<=m; i++)

		ans=(ans+(c(n+w-h-1,w+i-1)*c(h+m-w-1,m-w-i)%mod))%mod;

	cout<<ans;

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.2135881532688428x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

const ll mod=1e9+7;

const int maxn=2e5+100;

ll fac[maxn],f[maxn];

ll fpow(ll x, ll c) { ll res = 1; for (; c > 0; c >>= 1) { if (c & 1) res = res * x % mod; x = x * x % mod; }return res; }



ll comb(ll x, ll y) {

	return fac[x] * fpow(fac[y] * fac[x - y] % mod, mod - 2) % mod;

}



void init(int n) { fac[0] = fac[1] = 1; for(int i=2;i<=n;i++) fac[i] = i * fac[i - 1] % mod; }

int main(){

	init(200010);

	int n,m,a,b;

	cin>>n>>m>>a>>b;

	int x=n-a,y=b+1;

	ll ans=0;

  while(x>=1&&y<=m){

		ans=(ans+comb(x+y-1-1,x-1)*comb(n+m-x-y,n-x))%mod;

		x--,y++;

	}

	cout<<ans<<'\n';

}
// Slower C++ solution:
#include <iostream>

#include <cstdio>

#define int long long

#define N 200002

using namespace std;

const int mod=1000000007;

int a,b,x,y,i,j,f[N],inv[N];

int poww(int a,int b)

{

	int ans=1,base=a;

	while(b){

		if(b&1) ans=ans*base%mod;

		base=base*base%mod;

		b>>=1;

	}

	return ans;

}

int C(int n,int m)

{

	return f[n]*inv[m]%mod*inv[n-m]%mod;

}

signed main()

{

	cin>>a>>b>>x>>y;

	f[0]=1;

	for(i=1;i<=200000;i++) f[i]=f[i-1]*i%mod;

	inv[200000]=poww(f[200000],mod-2);

	for(i=199999;i>=0;i--) inv[i]=inv[i+1]*(i+1)%mod;

	int ans=C(a+b-2,b-1);

	for(i=a-x+1;i<=a-x+1;i++){

		for(j=1;j<=y;j++) ans=(ans-C(i+j-3,j-1)*C(a+b-i-j,b-j)%mod+mod)%mod;

	}

	cout<<(ans+mod)%mod<<endl;

	return 0;

}


// Faster C++ solution for the same problem (measured speedup: 1.6518572342932452x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

const ll mod=1e9+7;

const int maxn=2e5+100;

ll fac[maxn],f[maxn];

ll fpow(ll x, ll c) { ll res = 1; for (; c > 0; c >>= 1) { if (c & 1) res = res * x % mod; x = x * x % mod; }return res; }



ll comb(ll x, ll y) {

	return fac[x] * fpow(fac[y] * fac[x - y] % mod, mod - 2) % mod;

}



void init(int n) { fac[0] = fac[1] = 1; for(int i=2;i<=n;i++) fac[i] = i * fac[i - 1] % mod; }

int main(){

	init(200010);

	int n,m,a,b;

	cin>>n>>m>>a>>b;

	int x=n-a,y=b+1;

	ll ans=0;

  while(x>=1&&y<=m){

		ans=(ans+comb(x+y-1-1,x-1)*comb(n+m-x-y,n-x))%mod;

		x--,y++;

	}

	cout<<ans<<'\n';

}
// Slower C++ solution:
#include<cstdio>

#include<cstring>

#include<algorithm>

#define LL long long

using namespace std;

const int mod=1e9+7,M=1e6+7;

LL read(){

	LL ans=0,f=1,c=getchar();

	while(c<'0'||c>'9'){if(c=='-') f=-1; c=getchar();}

	while(c>='0'&&c<='9'){ans=ans*10+(c-'0'); c=getchar();}

	return ans*f;

}

LL n,m,A,B;

LL qmod(LL a,LL b){

	LL ans=1;

	while(b){

		if(b&1) ans=ans*a%mod;

		b>>=1; a=a*a%mod;

	}

	return ans;

}

LL w[M],f[M];

void pre(){

	int mx=2e5; w[0]=1;

	for(int i=1;i<=mx;i++) w[i]=w[i-1]*i%mod;

	f[mx]=qmod(w[mx],mod-2);

	for(int i=mx;i>=1;i--) f[i-1]=f[i]*i%mod;

} 

LL C(LL n,LL m){return w[n]*f[n-m]%mod*f[m]%mod;}

LL F(int x,int y,int nx,int ny){

	int p=nx-x,q=ny-y;

	return C(p+q,q);

}

LL ans;

int main(){

	pre();

	n=read(); m=read(); A=read(); B=read();

	ans=F(1,1,n,m);

	for(int i=1;i<=B;i++){

		int sum=F(1,1,n-A,i)*F(n-A+1,i,n,m)%mod;

		ans=(ans-sum)%mod;

		ans=(ans+mod)%mod;

	}

	printf("%lld\n",ans);

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3439260506896893x):
#include<bits/stdc++.h>

using namespace std;

#define ll long long

const ll mod=1e9+7;

const int maxn=2e5+100;

ll fac[maxn],f[maxn];

ll fpow(ll x, ll c) { ll res = 1; for (; c > 0; c >>= 1) { if (c & 1) res = res * x % mod; x = x * x % mod; }return res; }



ll comb(ll x, ll y) {

	return fac[x] * fpow(fac[y] * fac[x - y] % mod, mod - 2) % mod;

}



void init(int n) { fac[0] = fac[1] = 1; for(int i=2;i<=n;i++) fac[i] = i * fac[i - 1] % mod; }

int main(){

	init(200010);

	int n,m,a,b;

	cin>>n>>m>>a>>b;

	int x=n-a,y=b+1;

	ll ans=0;

  while(x>=1&&y<=m){

		ans=(ans+comb(x+y-1-1,x-1)*comb(n+m-x-y,n-x))%mod;

		x--,y++;

	}

	cout<<ans<<'\n';

}