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: Wrong Answer)

import javax.print.DocFlavor;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;
        PrintWriter pw = new PrintWriter(System.out);

        st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int a = Integer.parseInt(st.nextToken());
        int b = Integer.parseInt(st.nextToken());

        final int mod = 1000000007;

        int val = modularExponentiation(n, mod);

        long val1 = ncr(n, a, mod);
        long val2 = ncr(n, b, mod);

        long ans = val - val1 - val2 - 1;

        ans += mod;
        ans %= mod;

        pw.println(ans);


        
        
        
        
        
        
        
        pw.flush();
        pw.close();
    }

    static int modularExponentiation(int n, int mod) {
        if(n == 1) return 2;
        int val = modularExponentiation(n/2, mod);
        val = (int)(((long)val*val)%mod);
        if(n%2==1) val *= 2;
        return val;
    }

    static long ncr(int n, int r, int mod) {
        if(r > n-r) {
            r = n-r;
        }

        long prod = 1;
        for(int i=1 ; i<=r ; i++) {
            int cn = n - r + i;
            prod *= cn;
            prod %= mod;

            prod *= modInverse(i, mod);
            prod %= mod;
        }

        return prod;
    }

    static int modInverse(int a, int m) {
        int m0 = m;
        int y = 0, x = 1;
        if (m == 1) return 0;
        while(a > 1) {
            int q = a / m;
            int t = m;
            m = a % m;
            a = t;
            t = y;
            y = x - q * y;
            x = t;
        }
        if (x < 0) x += m0;
        return x;
    }
}