import java.util.*

fun main(args: Array<String>) {
    solve(Scanner(System.`in`))
}

class ModInt(var value: Long) {
    override fun toString(): String = value.toString()

    // 加減乗算は結果を毎回 mod P すれば良い
    operator fun plus(b: Long): ModInt =
        ModInt((this.value + b) % MOD)

    operator fun plus(b: ModInt): ModInt =
        ModInt((this.value + b.value) % MOD)

    operator fun plusAssign(b: Long) {
        this.value += b
        this.value %= MOD
    }

    operator fun plusAssign(b: ModInt) {
        this.value += b.value
        this.value %= MOD
    }

    operator fun minus(b: Long): ModInt =
        ModInt((this.value + MOD - b) % MOD)

    operator fun minus(b: ModInt): ModInt =
        ModInt((this.value + (MOD - b.value)) % MOD)

    operator fun minusAssign(b: Long) {
        this.value += MOD - b
        this.value %= MOD
    }

    operator fun minusAssign(b: ModInt) {
        this.value += MOD - b.value
        this.value %= MOD
    }

    operator fun times(b: Long): ModInt =
        ModInt((this.value * b) % MOD)

    operator fun times(b: ModInt): ModInt =
        ModInt((this.value * b.value) % MOD)

    operator fun timesAssign(b: Long) {
        this.value *= b
        this.value %= MOD
    }

    operator fun timesAssign(b: ModInt) {
        this.value *= b.value
        this.value %= MOD
    }

    // b で割る = 1/b を掛ける
    // フェルマーの小定理から、b の逆数 1/b (mod P) = b^(P-2)
    operator fun div(b: Long): ModInt =
        this * ModInt(b).pow(MOD - 2)

    operator fun div(b: ModInt): ModInt =
        this * b.pow(MOD - 2)

    operator fun divAssign(b: ModInt) {
        this *= b.pow(MOD - 2)
    }

    operator fun divAssign(b: Long) {
        this *= ModInt(b).pow(MOD - 2)
    }

    // 累乗 (mod P)
    // 計算量は O(log p)
    fun pow(p: Long): ModInt = when {
        p == 0L -> ModInt(1)
        p % 2 == 1L -> this * this.pow(p - 1)
        else -> {
            val half = this.pow(p / 2)
            half * half
        }
    }

    companion object {
        const val MOD = 1000000007L

        // aCb (mod P)
        fun combination(a: Long, b: Long): Long =
            if (b > a - b) {
                combination(a, a - b)
            } else {
                (ModInt((0L until b).fold(1L) { acc, i -> (acc * (a - i)) % MOD })
                        / (1L..b).fold(1L) { acc, i -> ((acc * i) % MOD) }).value
            }
    }
}

fun solve(sc: Scanner) {
    val N = sc.nextLong()
    val A = sc.nextLong()
    val B = sc.nextLong()

    val n = ModInt(2).pow(N)
    n -= 1
    n -= ModInt.combination(N, A)
    n -= ModInt.combination(N, B)
    println(n)
}
