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)

import Control.Monad
import Data.Array

main = sol <$> get >>= print

get = fmap read . words <$> getLine

sol [h,w,a,b] = sum [sq x b*sq (h-x+1) (w-b) | x <- [1..h-a]]
  where
  sq x y = chs (x+y-2) (x-1)
  chs n m = fac!n * inv (fac!m * fac!(n-m))
  fac = array (0,w+h-1) $ (0,1):[(i,fac!(i-1) * Modulo i) | i <- [1..w+h-1]]

inv :: Modulo -> Modulo
inv 1 = 1
inv a = pwr a (p-2)

-- Modular power
pwr :: Modulo -> Int -> Modulo
pwr a n
  | n == 0    = 1
  | odd n     = a*r
  | otherwise = r
  where
  q = pwr a (n `div` 2)
  r = q*q

p = 10^9+7 :: Int

-- | Modulo of Int
newtype Modulo = Modulo { getInt :: Int } deriving (Eq, Ord)

instance Num Modulo where
  Modulo a + Modulo b = Modulo ((a + b) `mod` p)
  Modulo a - Modulo b = Modulo ((a - b) `mod` p)
  Modulo a * Modulo b = Modulo ((a * b) `mod` p)
  abs = undefined
  negate = undefined
  signum = undefined
  fromInteger i = Modulo (fromIntegral i `mod` p)

instance Show Modulo where
  show (Modulo i) = show i

-- Modular inverse as needed
instance Fractional Modulo where
  recip = inv
  fromRational = undefined

{-
-- Modular multiplicative inverse
inv :: Modulo -> Modulo
inv 1 = 1
inv a = pwr a (p-2)

-- Modular power Int
pwr :: Modulo -> Int -> Modulo
pwr a n
  | n == 0    = 1
  | odd n     = a*r
  | otherwise = r
  where
  q = pwr a (n `div` 2)
  r = q*q

-- Modular factorial Int
fac :: Int -> Modulo
fac 0 = 1
fac n = Modulo n*fac (n-1)

-- Modular choose
choose :: Int -> Int -> Modulo
choose n m = fac' n m' * inv (fac m')
  where 
  m' = min m (n-m)

fac' :: Int -> Int -> Modulo
fac' _ 0 = 1
fac' n m = Modulo n*fac' (n-1) (m-1)
-}