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()
}

fn main() {
    let h: i64 = input();
    let w: i64 = input();
    let a: i64 = input();
    let b: i64 = input();

    let mut factorial = vec![0; (h + w + 1) as usize];
    factorial[0] = 1;
    factorial[1] = 1;
    for i in 1..h + w + 1 {
        factorial[i as usize] = factorial[i as usize - 1] * i % MOD;
    }

    let mut ans = 0;
    let mut i = 0;
    loop {
        let (p, q) = (h - a - i, b + 1 + i);
        if p < 1 || q > w {
            break;
        }
        ans += comb(p - 1 + q - 1, p - 1, &factorial) * comb(h - p + w - q, h - p, &factorial);
        ans %= MOD;
        i += 1;
    }

    println!("{}", ans);
}

const MOD: i64 = 1000000007;

fn comb(n: i64, k: i64, factorial: &Vec<i64>) -> i64 {
    let mut ans = factorial[n as usize];
    ans *= inverse(factorial[(n - k) as usize]);
    ans %= MOD;
    ans *= inverse(factorial[k as usize]);
    ans %= MOD;
    ans
}

fn inverse(n: i64) -> i64 {
    power(n, MOD - 2)
}

fn power(n: i64, p: i64) -> i64 {
    if p == 0 {
        1
    } else if p % 2 == 0 {
        let t = power(n, p / 2);
        t * t % MOD
    } else {
        power(n, p - 1) * n % MOD
    }
}