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 Go (1.6) (judge verdict: Accepted)

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
)

var sc *bufio.Scanner

func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

const MOD = 1000000007

func main() {
	sc = bufio.NewScanner(os.Stdin)
	sc.Buffer(make([]byte, 0), 1000000001*3)
	sc.Split(bufio.ScanWords)
	h, w, a, b := nextInt(), nextInt(), nextInt(), nextInt()

	fact := make([]int, h+w-1)
	inv := make([]int, h+w-1)
	finv := make([]int, h+w-1)
	fact[0], fact[1] = 1, 1
	finv[0], finv[1] = 1, 1
	inv[1] = 1
	for i := 2; i < h+w-1; i++ {
		fact[i] = (fact[i-1] * i) % MOD
		inv[i] = MOD - ((inv[MOD%i] * (MOD / i)) % MOD)
		finv[i] = (finv[i-1] * inv[i]) % MOD
	}

	n1, n2 := h-a+b-1, w+a-b-1
	ans := 0
	for k := 0; b+k <= n1 && a+k <= n2; k++ {
		c1 := (fact[n1] * ((finv[b+k] * finv[n1-(b+k)]) % MOD)) % MOD
		c2 := (fact[n2] * ((finv[a+k] * finv[n2-(a+k)]) % MOD)) % MOD
		ans = (ans + ((c1 * c2) % MOD)) % MOD
	}
	fmt.Println(ans)
}