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 Haskell (GHC 7.10.3) (judge verdict: Accepted)

import Data.Int (Int64)

p::Int64
p = 10^9 + 7

modPow::Int64->Int64->Int64
modPow a n | n == 1 = mod a p
           | mod n 2 == 1 = mod (a * modPow a (n-1)) p
           | otherwise = mod (t * t) p
                where t = modPow a (n `div` 2)

combination::Int64->Int64->Int64
combination n m = mod (x * (modPow y (p-2))) p
                    where x = foldl1 (\acc c -> mod (acc * c) p ) [(n-m+1)..n]
                          y = foldl1 (\acc c -> mod (acc * c) p ) [1..m]
                          
subMod::Int64->Int64->Int64
subMod x y
  | x < y     = x - y + p
  | otherwise = x - y

main = do
  [n, a, b] <- map read . words <$> getLine::IO[Int64]
  print $ ((modPow 2 n) - 1) `subMod` (combination n a) `subMod` (combination n b)