#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>
#include <cassert>
#include <array>
#include <tuple>
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>
using namespace std;
using ll = long long;
#define rep(i,k) for (int i = 0; i < (int)(k); i++)
#define all(c) begin(c), end(c)

const int mod = 1000000007;

template<int M>
struct Mint {
    int x;
    Mint() : x(0) {}
    Mint(int y) : x(y >= 0 ? y % M : M - (-y) % M) {}
    Mint &operator += (const Mint &rhs) { if ((x += rhs.x) >= M) x -= M; return *this; }
    Mint &operator -= (const Mint &rhs) { if ((x += M - rhs.x) >= M) x -= M; return *this; }
    Mint &operator *= (const Mint &rhs) { x = 1LL * x*rhs.x % M; return *this; }
    Mint &operator /= (const Mint &rhs) { x = (1LL * x*rhs.inv().x) % M; return *this; }
    Mint operator - () const { return Mint(-x); }
    Mint operator + (const Mint &rhs) const { return Mint(*this) += rhs; }
    Mint operator - (const Mint &rhs) const { return Mint(*this) -= rhs; }
    Mint operator * (const Mint &rhs) const { return Mint(*this) *= rhs; }
    Mint operator / (const Mint &rhs) const { return Mint(*this) /= rhs; }
    bool operator < (const Mint &rhs) const { return x < rhs.x; }
    Mint inv() const {
        signed a = x, b = M, u = 1, v = 0, t;
        while (b) { t = a / b; a -= t * b; swap(a, b); u -= t * v; swap(u, v); }
        return Mint(u);
    }
    Mint pow(long long t) const {
        Mint e = *this, res = 1;
        for (; t; e *= e, t >>= 1) if (t & 1) res *= e;
        return res;
    }
};
template <int M>
ostream &operator << (ostream &os, const Mint<M> &rhs) {
    return os << rhs.x;
}
template <int M>
istream &operator >> (istream &is, Mint<M> &rhs) {
    long long s; is >> s; rhs = Mint<M>(s); return is;
};

using mint = Mint<mod>;

struct Comb {
    int sz;
    vector<mint> mfact, mfinv;
    Comb(int N) : sz(min(N, mod - 1)), mfact(sz + 1), mfinv(sz + 1) {
        for (int i = 0; i <= sz; i++) mfact[i] = (i == 0 ? 1 : mfact[i - 1] * i);
        mfinv[sz] = mfact[sz].inv();
        for (int i = sz; i >= 1; i--) mfinv[i - 1] = mfinv[i] * i;
    }
    mint fact(int n, int& e) { // e に p の指数が入る
                               // Wilson の定理
        e = 0;
        if (n <= sz) return mfact[n];
        mint res = fact(n / mod, e);
        e += n / mod;
        if (n / mod % 2 != 0) return -res * mfact[n % mod];
        return res * mfact[n % mod];
    }
    mint nPr(int n, int r) {
        int e; return fact(n, e) / fact(n - r, e);
    }
    mint nCr(int n, int r) {
        // Lucus の定理
        assert(n <= sz);
        if (n >= mod) return nCr(n%mod, r%mod) * nCr(n / mod, r / mod);
        return r > n ? 0 : mfact[n] * mfinv[n - r] * mfinv[r];
    }
    mint nHr(int n, int r) {
        return r == 0 ? 1 : nCr(n + r - 1, r);
    }
};


int h, w;
int a, b;

int main() {
    while (cin >> h >> w) {
        cin >> a >> b;
        Comb c(200010);
        mint s = c.nCr(h + w - 2, h- 1);
        mint p = 0;
        for (int i = 1; i <= b; ++i) {
            mint f = c.nCr((h - a) + i - 2, i - 1) * c.nCr(a + (w - i + 1) - 2, (w - i + 1) - 1);
            p += f;
        }
        cout << (s - p).x << endl;
    }
}

Measured memory_bytes: 1792