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 Rust (1.15.1) (judge verdict: Accepted)

use std::ops::Sub;
use std::ops::Div;
use std::ops::Mul;
use std::ops::Rem;
use std::ops::ShrAssign;
use std::ops::BitAnd;
use std::cmp::min;

const MOD: i64 = 1000000007;


fn main() {
    let (n, a, b) = read_tuple::<i64>();

    let r = min(n as usize, 2e5 as usize) + 1;
    let m = MOD;
    let mut finv = Vec::with_capacity(r);
    finv.push(1);
    finv.push(1);
    let mut inv = Vec::with_capacity(r);
    inv.push(1);
    inv.push(1);
    for i in 2..r {
        let i = i as i64;
        let tmp = m - inv[(m % i) as usize] * (m / i) % m;
        inv.push(tmp);
        let tmp = finv.last().unwrap() * inv.last().unwrap() % m;
        finv.push(tmp);
    }


    let total: i64 = modpow(2, n, MOD) - 1;

    let nca = {
        let a = min(a, n-a);
        let mut tmp = 1;
        for i in (n-a+1)..(n + 1) {
            tmp *= i;
            tmp %= MOD;
        }
        tmp *= finv[a as usize];
        tmp %= MOD;
        tmp
    };

    let ncb = {
        let b = min(b, n-b);
        let mut tmp = 1;
        for i in (n-b+1)..(n + 1) {
            tmp *= i;
            tmp %= MOD;
        }
        tmp *= finv[b as usize];
        tmp %= MOD;
        tmp
    };

    let mut ans = total - nca;
    if ans < 0 {
        ans += MOD;
    }
    ans -= ncb;
    if ans < 0 {
        ans += MOD;
    }
    

    println!("{:?}", ans);
}


pub fn modpow<T>(mut a: T, mut n: T, m: T) -> T
    where T: Sub<Output=T> + Div<Output=T> + Mul<Output=T> + Rem<Output=T> + ShrAssign + PartialOrd + BitAnd<Output=T> + Copy + From<u8>
{
    let zero = T::from(0);
    let one = T::from(1);
    let mut res = one;

    while n > zero {
        if (n & one) == one {
            res = res * a % m;
        }
        a = a * a % m;
        n >>= one;
    }

    res
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().split_whitespace()
        .map(|e| e.parse().ok().unwrap()).collect()
}
fn read_tuple<T: std::str::FromStr + Copy>() -> (T, T, T) {
    let temp = read_vec();
    (temp[0], temp[1], temp[2])
}