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 Java8 (OpenJDK 1.8.0) (judge verdict: Accepted)

import java.io.*;
import java.util.*;

public class Main {
    public static void main(final String[] args) throws Exception {
        final Scanner sc = new Scanner(System.in);
        long n;
        n = sc.nextLong();
        long a;
        a = sc.nextLong();
        long b;
        b = sc.nextLong();

        final Solver solver = new Solver();
        solver.solve(n, a, b);
    }
}

class Solver {
    static final long MOD = 1000000007;

    public void solve(long n, long a, long b) {
        long all = iterativePow(2, n, MOD) % MOD;

        long allButA = calcSub(n, a, MOD);
        long allButB = calcSub(n, b, MOD);

        long ans = (all + MOD - 1) % MOD; // Ignore the case where no flower selected
        ans = (ans + MOD - allButA) % MOD;
        ans = (ans + MOD - allButB) % MOD;

        System.out.println(ans);
    }

    private long calcSub(long n, long k, long mod) {
        long x = permutation(n, k, mod);
        long y = permutation(k, k, mod);
        long invY = iterativePow(y, mod - 2, mod);

        return x * invY % mod;
    }

    private long permutation(long n, long k, long mod) {
        long ans = 1;
        for (long i = n - k + 1; i <= n; i++) {
            ans *= i;
            ans %= mod;
        }
        return ans;
    }

    private long invMod(long n, long mod) {
        return iterativePow(n, mod - 2, mod);
    }

    private long iterativePow(long n, long p, long mod) {
        if (p == 0) {
            return 1;
        }
        if (p % 2 == 0) {
            long pow = iterativePow(n, p / 2, mod);
            return pow * pow % mod;
        }
        return n * iterativePow(n, p - 1, mod) % mod;
    }
}