#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <map>
#include <set>
#include <vector>

template <std::size_t MOD>
class ModuloInteger
{
public:
    ModuloInteger(const std::size_t init)
        : value(init)
    {
    }

    using value_t = std::size_t;

    ModuloInteger operator+(const ModuloInteger value) const;
    void operator+=(const ModuloInteger value);

    ModuloInteger operator-(const ModuloInteger value) const;
    void operator-=(const ModuloInteger value);

    ModuloInteger operator*(const ModuloInteger value) const;
    void operator*=(const ModuloInteger value);

    ModuloInteger operator/(const ModuloInteger value) const;
    void operator/=(const ModuloInteger value);

    ModuloInteger operator+(const std::size_t value) const;
    void operator+=(const std::size_t value);

    ModuloInteger operator-(const std::size_t value) const;
    void operator-=(const std::size_t value);

    ModuloInteger operator*(const std::size_t value) const;
    void operator*=(const std::size_t value);

    ModuloInteger operator/(const std::size_t value) const;
    void operator/=(const std::size_t value);

    ModuloInteger inv() const;

    ModuloInteger powi(const std::size_t index) const;

    std::size_t value;
};

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::powi(const std::size_t index) const
{
    if (index == 0)
    {
        return 1;
    }
    else if (index == 1)
    {
        return *this;
    }
    else if (index % 2 == 0)
    {
        auto v = powi(index / 2);
        return v * v;
    }
    else
    {
        return powi(index - 1) * (*this);
    }
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::inv() const
{
    return powi(MOD - 2);
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator+(const ModuloInteger value) const
{
    return (this->value + value.value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator+=(const ModuloInteger value)
{
    this->value = (this->value + value.value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator-(const ModuloInteger value) const
{
    return (this->value + MOD - value.value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator-=(const ModuloInteger value)
{
    this->value = (this->value - value.value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator*(const ModuloInteger value) const
{
    return (this->value * value.value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator*=(const ModuloInteger value)
{
    this->value = (this->value * value.value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator/(const ModuloInteger value) const
{
    return (this->value * value.inv().value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator/=(const ModuloInteger value)
{
    this->value = (this->value * value.inv().value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator+(const std::size_t value) const
{
    return (this->value + value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator+=(const std::size_t value)
{
    this->value = (this->value + value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator-(const std::size_t value) const
{
    return (this->value + MOD - value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator-=(const std::size_t value)
{
    this->value = (this->value - value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator*(const std::size_t value) const
{
    return (this->value * value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator*=(const std::size_t value)
{
    this->value = (this->value * value) % MOD;
}

template <std::size_t MOD>
ModuloInteger<MOD> ModuloInteger<MOD>::operator/(const std::size_t value) const
{
    return (this->value * ModuloInteger<MOD>(value).inv().value) % MOD;
}

template <std::size_t MOD>
void ModuloInteger<MOD>::operator/=(const std::size_t value)
{
    this->value = (this->value * ModuloInteger<MOD>(value).inv().value) % MOD;
}

template <std::size_t MOD>
std::ostream& operator<<(std::ostream& out, const ModuloInteger<MOD> value)
{
    out << value.value;
    return out;
}

using namespace std;

constexpr size_t mod = 1000000007;

using modint = ModuloInteger<mod>;

modint comb(const std::size_t n, const std::size_t m, const std::vector<modint>& mod_fact)
{
    return mod_fact[n] * mod_fact[n - m].inv() * mod_fact[m].inv();
}

int main()
{
    int64_t h, w, a, b;
    cin >> h >> w >> a >> b;

    std::vector<modint> mod_fact;
    for (size_t i = 0; i <= h + w; i++)
    {
        mod_fact.emplace_back(i);
    }
    mod_fact[0] = 1;
    for (size_t i = 1; i < mod_fact.size() - 1; i++)
    {
        mod_fact[i + 1] *= mod_fact[i];
    }

    modint ans(0);
    for (int i = 0; i < h - a; i++)
    {
        ans += comb(i + b - 1, i, mod_fact) * comb(h - i + w - b - 2, w - b - 1, mod_fact);
    }

    cout << ans << endl;
}


Measured memory_bytes: 2420