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: Accepted)

def extended_gcd(a, b)
  last_remainder, remainder = a.abs, b.abs
  x, last_x, y, last_y = 0, 1, 1, 0
  while remainder != 0
    last_remainder, (quotient, remainder) = remainder, last_remainder.divmod(remainder)
    x, last_x = last_x - quotient*x, x
    y, last_y = last_y - quotient*y, y
  end

  return last_remainder, last_x * (a < 0 ? -1 : 1)
end

def invmod(e, et)
  g, x = extended_gcd(e, et)
  if g != 1
    raise 'The maths are broken!'
  end
  x % et
end

MOD = 10**9 + 7
h,w,a,b = gets.chomp.split().map(&:to_i)

hw = h+w
kaijo = Array.new(hw)
kaijo[0] = 1
1.upto(hw).each do |i|
  kaijo[i] = (kaijo[i-1] * i) % MOD
end

ans = 0
(h-a).times do |i|
  path1 = ((kaijo[b-1 + i] * invmod(kaijo[b-1], MOD) % MOD) * invmod(kaijo[i], MOD)) % MOD
  path2 = ((kaijo[h-i-1 + w-b-1] * invmod(kaijo[h-i-1], MOD) % MOD) * invmod(kaijo[w-b-1], MOD)) % MOD
  #path1 = kaijo[b + i] / kaijo[b] / kaijo
  #path2 = kaijo[h-i + w-b] / kaijo[h-i] / kaijo[w-b]
  path = (path1 * path2) % MOD
  ans = (ans + path) % MOD
  #p [path1, path2, '', path, ans]
end

puts ans