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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

{-# OPTIONS_GHC -O #-}
import Data.List
import Data.Array.Unboxed

mp = 1000000007

powmod = pd' 1 where
    pd' x _ 0 = x
    pd' x a b
        | odd b = pd' (mod (x*a) mp) a (b-1)
        | otherwise = pd' x (mod (a*a) mp) (div b 2)

facts n = listArray (0,n) $ scanl' (\f n->(mod (f*n) mp)) 1 [1..]
ifacts fs = array (0,n) $ take (n+1) $ iterate psi (n,im) where
    n = snd $ bounds fs
    im = powmod (fs ! n) (mp-2)
    psi (n,m) = (n-1, mod (m*n) mp)

cmbmod fs ifs n k = (`mod` mp) $ (* t3) $ (`mod` mp) $ t1*t2 where
    t1 = fs ! n
    t2 = ifs ! k
    t3 = ifs ! (n-k)

main = do
    (h:w:a:b:_)<-map read.words<$>getLine::IO[Int]
    let fs = facts (h+w-2) :: UArray Int Int
    let ifs = ifacts fs :: UArray Int Int
    print $ foldl' (\a x->mod (a+x) mp) 0 $ unfoldr (way fs ifs) (b + (h-a-1), b, a-1 + (w-b-1), w-b-1)
way _ _ (_,_,_,-1) = Nothing
way fs ifs (n1,k1,n2,k2) = Just (mod (w1*w2) mp, (n1+1, k1+1, n2-1, k2-1)) where
    w1 = cmbmod fs ifs n1 k1
    w2 = cmbmod fs ifs n2 k2