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 C (Clang 3.8.0) (judge verdict: Accepted)

#include <inttypes.h>
#include <math.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

const intmax_t MOD = INTMAX_C(1e9) + 7;
const intmax_t MAX = INTMAX_C(2e5);

intmax_t modpow(intmax_t a, intmax_t n)
{
    intmax_t res = 1;
    while (n > 0) {
        if (n & 1)
            res = res * a % MOD;
        a = a * a % MOD;
        n >>= 1;
    }
    return res;
}

void swap(intmax_t *a, intmax_t *b)
{
    intmax_t t;
    t = *a;
    *a = *b;
    *b = t;
}

intmax_t modinv(intmax_t a, intmax_t m)
{
    intmax_t b = m, u = 1, v = 0;
    while (b) {
        intmax_t t = a / b;
        a -= t * b;
        swap(&a, &b);
        u -= t * v;
        swap(&u, &v);
    }
    u %= m;
    if (u < 0)
        u += m;
    return u;
}

intmax_t nCk(intmax_t n, intmax_t k)
{
    intmax_t a = 1, b = 1;
    for (size_t i = (n - k + 1); i <= n; i++) {
        a *= i;
        a %= MOD;
    }
    for (size_t i = 1; i <= k; i++) {
        b *= i;
        b %= MOD;
    }
    return a * modinv(b, MOD) % MOD;
}

int main(void)
{
    intmax_t n, a, b;
    intmax_t ans = 0;

    scanf("%jd%jd%jd", &n, &a, &b);

    ans = modpow(2, n);

    intmax_t nCa = nCk(n, a);
    intmax_t nCb = nCk(n, b);

    ans -= nCa;
    ans %= MOD;
    if (ans < 0)
        ans += MOD;

    ans -= nCb;
    ans %= MOD;
    if (ans < 0)
        ans += MOD;

    ans -= 1;
    ans %= MOD;
    if (ans < 0)
        ans += MOD;

    printf("%jd\n", ans);

    return 0;
}