#include <stdio.h>
#include <stdlib.h>
#include <map>
#include <vector>
#include <utility>

#define MAX_W (100000)
#define MAX_H (100000)

std::map<std::pair<long, long>, long> mp;
std::vector<std::pair<long, long>> l;

long comb_mod_recur(long n, long k, long mod) {
  // printf("(n, k) = (%ld, %ld)\n", n, k);
  // fflush(stdout);
  if (n == k || k == 0)
    return 1;
  std::pair<long, long> nk(n, k);
  if (mp.find(nk) == mp.end())
    mp[nk] = (comb_mod_recur(n - 1, k, mod) +
              comb_mod_recur(n - 1, k - 1, mod)) % mod;
  return mp[nk];
}

long comb_mod_iter(long n, long k, long mod) {
  // fflush(stdout);
  if (n == k || k == 0)
    return 1;

  l.push_back(std::pair<long, long>(n, k));
  while (l.size() != 0) {
    std::pair<long, long> nk = l[l.size() - 1];
    l.pop_back();
    if (mp.find(nk) == mp.end()) {  // no entry in map
      long n = nk.first, k = nk.second;
      printf("(n, k) = (%ld, %ld)\n", n, k);
      if (n == nk.second || k == 0) {  // can calculate instantly
        mp[nk] = 1;
      } else {  // must perform recursive calculation
        std::pair<long, long> nm1km1(n - 1, k - 1), nm1k(n - 1, k);
        bool nm1km1_exists = mp.find(nm1km1) != mp.end();
        bool nm1k_exists = mp.find(nm1k) != mp.end();
        if (nm1km1_exists && nm1k_exists) {  // can be calculated now
          mp[nk] = mp[nm1km1] + mp[nm1k];
        } else {  // cannot be calculated right now
          l.push_back(nk);
          if (!nm1km1_exists)
            l.push_back(nm1km1);
          if (!nm1k_exists)
            l.push_back(nm1k);
        }
      }
    }
  }
  
  return mp[std::pair<long, long>(n, k)];
}

int comb_mod_modinv_first_time = 1;
long fact_mod[MAX_H + MAX_W + 1] = {};
long fact_inv_mod[MAX_H + MAX_W + 1] = {};

long exp_mod(long x, long a, long mod) {
  long ret = 1;
  for (long k = x, b = a; b > 0; k = (k * k) % mod, b /= 2) {
    if (b % 2 == 1) 
      ret = (ret * k) % mod;
  }
  // printf("[exp_mod] x = %ld, a = %ld, mod = %ld, ret = %ld\n", x, a, mod, ret);
  return ret;
}

long comb_mod_modinv(long n, long k, long mod) {
  long ret = 1;
  if (comb_mod_modinv_first_time) {
    fact_mod[0] = 1;
    fact_inv_mod[0] = 1;
    for (int i = 1; i <= MAX_H + MAX_W; i++) {
      fact_mod[i] = (fact_mod[i - 1] * i) % mod;
      fact_inv_mod[i] = exp_mod(fact_mod[i], mod - 2, mod);
    }
    comb_mod_modinv_first_time = 0;
  }
  ret = (ret * fact_mod[n]) % mod;
  ret = (ret * fact_inv_mod[k]) % mod;
  ret = (ret * fact_inv_mod[n - k]) % mod;
  // printf("[comb_mod_modinv] n = %ld, k = %ld, mod = %ld, ret = %ld\n",
  //        n, k, mod, ret);
  return ret;
}

// long (*comb_mod)(long n, long k, long mod) = comb_mod_recur;
// long (*comb_mod)(long n, long k, long mod) = comb_mod_iter;
long (*comb_mod)(long n, long k, long mod) = comb_mod_modinv;

// doesn't finish in time...
int main(int argc, char *argv[]) {
  long H, W, A, B, mod = 1000000007, ans = 0;
  scanf("%ld %ld %ld %ld", &H, &W, &A, &B);
  for (int i = 0; i < H - A; i++) {
    ans = (ans + (comb_mod(B - 1 + i, i, mod)
                  * comb_mod(W - 1 - B + H - 1 - i, H - 1 - i, mod)) % mod) % mod;
  }
  printf("%ld\n", ans);
  
  return 0;
}


Measured memory_bytes: 3328