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 "fmt"

const (
	max = 100000
	mod = 1e9 + 7
)

var fact, invFact []int

func powmod(a, m int) int {
	b := 1
	for m > 0 {
		if m&1 != 0 {
			b = b * a % mod
		}
		a = a * a % mod
		m >>= 1
	}
	return b
}

func combmod(n, r int) int {
	c := fact[n]
	c *= invFact[n-r]
	c %= mod
	c *= invFact[r]
	c %= mod
	return c
}

func main() {
	var H, W, A, B int
	fmt.Scan(&H, &W, &A, &B)

	max := H + W + 1
	fact = make([]int, max+1)
	invFact = make([]int, max+1)
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= max; i++ {
		fact[i] = (i * fact[i-1]) % mod
		invFact[i] = powmod(i, mod-2)
		invFact[i] = (invFact[i] * invFact[i-1]) % mod
	}

	s := 0
	for i := 0; i < H-A; i++ {
		x := combmod(i+1+B-2, i)
		y := combmod(W-B+H-i-2, H-i-1)
		z := (x * y) % mod
		s = (s + z) % mod
	}
	fmt.Println(s)
}