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.42.0) (judge verdict: Accepted)

use proconio::fastout;
use whiteread::parse_line;

const MOD: usize = 1_000_000_007;

const MAX: usize = 250_000;

struct ComCalculator {
    fac: Vec<usize>,
    finv: Vec<usize>,
}

impl ComCalculator {
    fn new(n: usize) -> Self {
        let mut fac = Vec::with_capacity(n);
        let mut finv = Vec::with_capacity(n);
        let mut inv = Vec::with_capacity(n);

        fac.push(1);
        fac.push(1);
        finv.push(1);
        finv.push(1);
        inv.push(0); // dummy data
        inv.push(1);
        for i in 2..n {
            fac.push((fac[i - 1] * i) % MOD);
            inv.push(MOD - (inv[MOD % i] * (MOD / i) % MOD));
            finv.push((finv[i - 1] * inv[i]) % MOD);
        }

        Self { fac, finv }
    }

    fn calc(&self, n: usize, k: usize) -> usize {
        if n < k {
            return 0;
        }

        return (self.fac[n] * (self.finv[k] * self.finv[n - k] % MOD)) % MOD;
    }
}

fn path(a: usize, b: usize, com: &ComCalculator) -> usize {
    com.calc(a + b, a)
}

#[fastout]
fn main() {
    let (h, w, a, b): (usize, usize, usize, usize) = parse_line().unwrap();

    let com = ComCalculator::new(MAX);
    let mut ret = path(h - 1, w - 1, &com);
    for i in 0..a {
        ret = (MOD - (path(b - 1, h - a + i, &com) * path(w - b - 1, a - i - 1, &com) % MOD) + ret)
            % MOD;
    }
    println!("{}", ret);
}