Problem:
Score : 400 points

Problem Statement

Akari has n kinds of flowers, one of each kind.

She is going to choose one or more of these flowers to make a bouquet.

However, she hates two numbers a and b, so the number of flowers in the bouquet cannot be a or b.

How many different bouquets are there that Akari can make?

Find the count modulo (10^9 + 7).

Here, two bouquets are considered different when there is a flower that is used in one of the bouquets but not in the other bouquet.

Constraints

All values in input are integers.

2 \leq n \leq 10^9

1 \leq a < b \leq \textrm{min}(n, 2 \times 10^5)

Input

Input is given from Standard Input in the following format:

n a b

Output

Print the number of bouquets that Akari can make, modulo (10^9 + 7). (If there are no such bouquets, print 0.)

Sample Input 1

4 1 3

Sample Output 1

7

In this case, Akari can choose 2 or 4 flowers to make the bouquet.

There are 6 ways to choose 2 out of the 4 flowers, and 1 way to choose 4, so there are a total of 7 different bouquets that Akari can make.

Sample Input 2

1000000000 141421 173205

Sample Output 2

34076506

Print the count modulo (10^9 + 7).

Solution in Kotlin (1.0.0) (judge verdict: Runtime Error)

fun main(args: Array<String>) {
    val (N, A, B) = readLine()!!.split(" ").map { it.toInt() }
    val mod = 1000000007
    val com = COM(mod, 2 * 100000)
    com.modPow(2, N).let {
        val k = it - com.calculateLarge(N.toLong(), A)
        if(k < 0){
            k + mod
        }else{
            k % mod
        }
    }.let {
        val k = it - com.calculateLarge(N.toLong(), B)
        if(k < 0){
            k + mod
        }else{
            k % mod
        }
    }.let {
        val k = it - 1
        if(k < 0){
            k + mod
        }else{
            k % mod
        }
    }.let { println(it) }
}

class COM(
    val mod: Int,
    val max: Int
) {
    val fac = LongArray(max)
    val finv = LongArray(max)
    val inv = LongArray(max)

    init {
        fac[0] = 1
        fac[1] = 1
        finv[0] = 1
        finv[1] = 1
        inv[1] = 1

        for (i in 2 until max) {
            fac[i] = fac[i - 1] * i % mod
            inv[i] = mod - (inv[mod % i] * (mod / i)) % mod
            finv[i] = finv[i - 1] * inv[i] % mod
        }
    }

    fun calculate(n: Int, k: Int): Long {
        return fac[n] * (finv[k] * finv[n - k] % mod) % mod
    }

    fun calculateLarge(n: Long, k: Int): Long {
        var x = n
        var num = 1L
        repeat(k){
            num = (num * x) % mod
            x--
        }
        return num * finv[k] % mod
    }

    fun modPow(x: Int, n: Int): Long {
        if(n == 1){
            return x.toLong()
        }
        if(n % 2 == 0){
            val k = modPow(x, n / 2) % mod
            return k * k % mod
        }else{
            val k = modPow(x, (n - 1) / 2) % mod
            return (x * k * k) % mod
        }
    }
}