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 Ruby (2.3.3) (judge verdict: Wrong Answer)

# Try AtCoder
# author: Leonardone @ NEETSDKASU
############################################################
def gs() gets.chomp end
def gi() gets.to_i end
def gf() gets.to_f end
def gss() gs.split end
def gis() gss.map(&:to_i) end
def nmapf(n,f) n.times.map{ __send__ f } end
def ngs(n) nmapf n,:gs end
def ngi(n) nmapf n,:gi end
def ngss(n) nmapf n,:gss end
def ngis(n) nmapf n,:gis end
def arr2d(h,w,v=0) h.times.map{[v] * w} end
def for2p(hr,wr,&pr) hr.each{|i|wr.each{|j| yield(i,j)}} end
def nsum(n) n * (n + 1) / 2 end
def vcount(d,r=Hash.new(0)) d.inject(r){|m,e| m[e]+=1;m} end
MV4 = [[0, 1], [1, 0], [0, -1], [-1, 0]]
MV8 = MV4 + [[1, 1], [1, -1], [-1, -1], [-1, 1]]
DV7 = 7 + 10 ** 9
############################################################

# 解説読後
# http://arc058.contest.atcoder.jp/data/arc/058/editorial.pdf

# 二分累乗法
# http://chausson.eng.kagawa-u.ac.jp/Comp/Prog/DosC/Sec4/Note432.html

def binpow(v, e)
    a = 1
    x = v
    while e > 0
        if e.even?
            x = (x * x) % DV7
            e /= 2
        else
            a = (a * x) % DV7
            e -= 1
        end
    end
    a
end

H, W, A, B = gis

t = [0] * (H + W + 1)
b = [0] * (H + W + 1)

t[0] = 1
b[0] = 1
(1 .. (H + W)).each do |i|
    t[i] = (i * t[i - 1]) % DV7
    b[i] = binpow(i, DV7 - 2)
end

c = 0

(B ... W).each do |i|
    w1 = i
    h1 = H - A - 1
    c1 = (t[w1 + h1] * b[w1]) % DV7
    w2 = W - i - 1
    h2 = A - 1
    c2 = (t[w2 + h2] * b[w2]) % DV7
    c += (c1 * c2) % DV7
    c %= DV7
end

puts c