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 Rust (1.15.1) (judge verdict: Accepted)

use std::io::prelude::*;

fn input<T>() -> T
    where T: std::str::FromStr {
    let stdin = std::io::stdin();
    let token: String = stdin
        .lock()
        .bytes()
        .map(|c| c.unwrap() as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().unwrap()
}
static MOD: i64 = 1_000_000_000 + 7;

pub fn mod_pow(mut x: i64, mut n: i64) -> i64 {
    let mut res = 1i64;
    while n > 0 {
        if n % 2 == 1 {
            res = res * x % MOD;
        }
        x = x * x % MOD;
        n /= 2;
    }
    res
}
 
pub fn inv(x: i64) -> i64 {
    mod_pow(x, MOD - 2)
}


fn main() {
    let h = input::<usize>();
    let w = input::<usize>();
    let a = input::<usize>();
    let b = input::<usize>();
    let n = 200_000;

    let mut fact = vec![1; n];
    for i in 1..n {
       fact[i]  = fact[i-1] * i as i64 % MOD;
    }
    let f = |x: usize, y: usize| -> i64 {
        fact[x + y] * inv(fact[x])  % MOD * inv(fact[y]) % MOD
    };

    let mut cnt = 0;
    for i in 0..w - b {
        cnt += f(h-a-1, b+i) * f(a-1, w-b-1-i);
        cnt %= MOD;
    }
    println!("{}", cnt);
}