output_description: Print the number of ways she can travel to the bottom-right cell, modulo
  10^9+7.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      H W A B
attempt: class Combinatorics:
      def __init__(self, N, mod):
          """
          Preprocess for calculating binomial coefficients nCr (0 <= r <= n, 0 <= n <= N)
          over the finite field Z/(mod)Z.
          Input:
              N (int): maximum n
              mod (int): a prime number. The order of the field Z/(mod)Z over which nCr is calculated.
          """
          self.mod = mod
          self.fact = {i: None for i in range(N + 1)}  # n!
          self.inverse = {
              i: None for i in range(1, N + 1)
          }  # inverse of n in the field Z/(MOD)Z
          self.fact_inverse = {
              i: None for i in range(N + 1)
          }  # inverse of n! in the field Z/(MOD)Z
  
          # preprocess
          self.fact[0] = self.fact[1] = 1
          self.fact_inverse[0] = self.fact_inverse[1] = 1
          self.inverse[1] = 1
          for i in range(2, N + 1):
              self.fact[i] = i * self.fact[i - 1] % self.mod
              q, r = divmod(self.mod, i)
              self.inverse[i] = (-(q % self.mod) * self.inverse[r]) % self.mod
              self.fact_inverse[i] = self.inverse[i] * self.fact_inverse[i - 1] % self.mod
  
      def perm(self, n, r):
          """
          Calculate nPr = n! / (n-r)! % mod
          """
          if n < r or n < 0 or r < 0:
              return 0
          else:
              return (self.fact[n] * self.fact_inverse[n - r]) % self.mod
  
      def binom(self, n, r):
          """
          Calculate nCr = n! /(r! (n-r)!) % mod
          """
          if n < r or n < 0 or r < 0:
              return 0
          else:
              return (
                  self.fact[n]
                  * (self.fact_inverse[r] * self.fact_inverse[n - r] % self.mod)
                  % self.mod
              )
  
      def hom(self, n, r):
          """
          Calculate nHr = {n+r-1}Cr % mod.
          Assign r objects to one of n classes.
          Arrangement of r circles and n-1 partitions:
              o o o | o o | | | o | | | o o | | o
          """
          if n == 0 and r > 0:
              return 0
          if n >= 0 and r == 0:
              return 1
          return self.binom(n + r - 1, r)
  
  
  H, W, A, B = map(int, input().split())
  MOD = 10**9 + 7
  com = Combinatorics(H + W, MOD)
  ans = com.binom(H - 1 + W - 1, H - 1)
  for j in range(B):
      ans = (
          ans - com.binom(H - A - 1 + j, j) * com.binom(A - 1 + W - j - 1, A - 1)
      ) % MOD
  print(ans)
  
problem_description: 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.
samples: [{"input": "2 3 1 1", "output": "2\n    \n\nWe have a 2\u00d73 grid, but entering the bottom-left cell is forbidden. The number\nof ways to travel is two: \"Right, Right, Down\" and \"Right, Down, Right\".\n\n* * *"}, {"input": "10 7 3 4", "output": "3570\n    \n\nThere are 12 forbidden cells.\n\n* * *"}, {"input": "100000 100000 99999 99999", "output": "1\n    \n\n* * *"}, {"input": "100000 100000 44444 55555", "output": "738162020"}]