import java.util.*
import java.math.*

private val readString: ()->String = {readLine()!!}
private val readInt: ()->Int = { readLine()!!.toInt() }
private val readLong: ()->Long = { readLine()!!.toLong() }
private val readListInt: ()->List<Int> = { readLine()!!.split(' ').map(String::toInt) }
private val readListLong: ()->List<Long> = { readLine()!!.split(' ').map(String::toLong) }
private val errPrintln: (String)->Unit = { msg -> System.err.println(msg) }
private val MOD = 1e9.toLong()+7


class LongMod(var num: Long, val MOD: Long = 1e9.toLong()+7) {
    init {
        this.num = (this.num%this.MOD + this.MOD)%this.MOD
    }
    constructor(numStr: String, MOD: Long = 1e9.toLong()+7) :
            this(0L, MOD) {
        if (numStr.isEmpty()) return
        var rv = numStr.reversed()
        var d = 1L
        rv.forEach{ c ->
            this.num += (c - '0') * d
            this.num %= MOD
            d *= 10
            d %= MOD
        }
    }
    override operator fun equals(other: Any?): Boolean {
        if (other !is LongMod) return false
        return this.num % this.MOD == other.num % this.MOD
    }
    operator fun unaryMinus(): LongMod {
        return LongMod(-this.num)
    }
    operator fun plusAssign(other: LongMod): Unit {
        if ((this.num + other.num) >= this.MOD) {
            this.num -= this.MOD
        }
        this.num += other.num
    }
    operator fun minusAssign(other: LongMod): Unit {
        if ((this.num + this.MOD - other.num) >= this.MOD) {
            this.num -= this.MOD
        }
        this.num += this.MOD - other.num
    }
    operator fun timesAssign(other: LongMod): Unit {
        this.num *= other.num
        this.num %= this.MOD
    }
    operator fun plus(other: LongMod): LongMod {
        val res = LongMod(this.num, this.MOD)
        res += other
        return res
    }
    operator fun minus(other: LongMod): LongMod {
        val res = LongMod(this.num, this.MOD)
        res -= other
        return res
    }
    operator fun times(other: LongMod): LongMod {
        val res = LongMod(this.num, this.MOD)
        res *= other
        return res
    }
    tailrec fun pow(n: Long): LongMod {
        if (n == 0L) return LongMod(1L, this.MOD)
        var x = this.pow(n / 2)
        x.timesAssign(x)
        if (n % 2 == 1L) x.timesAssign(this)
        return x
    }
    fun inv(): LongMod {
        return this.pow(this.MOD - 2)
    }
    operator fun divAssign(other: LongMod): Unit {
        this *= other.inv()
    }
    operator fun div(other: LongMod): LongMod {
        val res = LongMod(this.num, this.MOD)
        res /= other
        return res
    }
}
class NckModLongTbl(val N: Int, val MOD: Long = 1e9.toLong()+7) {
    private var fact = arrayOf<LongMod>()
    private var iFact = arrayOf<LongMod>()
    init {
        this.fact = Array<LongMod>(N+1){LongMod(0L, MOD)}
        this.iFact = Array<LongMod>(N+1){LongMod(0L, MOD)}
        this.fact[0] = LongMod(1L, MOD)
        for (i in 1..N) {
            this.fact[i] = this.fact[i-1] * LongMod(i.toLong(), MOD)
        }
        this.iFact[N] = this.fact[N].inv()
        for (i in N downTo 1) {
            this.iFact[i-1] = this.iFact[i] * LongMod(i.toLong(), MOD)
        }
    }
    fun nCkMod(N: Int, K: Int): LongMod {
        if (K < 0 || N < K) return LongMod(0L, MOD)
        return this.fact[N] * this.iFact[K] * this.iFact[N-K]
    }
}


fun solveB(H: Int, W: Int, A: Int, B: Int): Long {
    val tbl = NckModLongTbl(H+W, MOD)

    var res = LongMod(0L, MOD)
    for (i in B until W) {
        res = res + tbl.nCkMod(H-A-1 + i, i) * tbl.nCkMod(A-1 + W-i-1, W-i-1)
    }

    return res.num
}


fun main(args: Array<String>) {
    val (H,W,A,B) = readListInt()

    val ans = solveB(H, W, A, B)

    println(ans)
}


Measured memory_bytes: 84044