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 qualified Data.Vector.Unboxed.Mutable as VUM
import qualified Data.Vector.Unboxed as VU
import Control.Monad

powMod :: Int -> Int -> Int -> Int
powMod n k m
    | k == 0 = 1
    | odd k = (powMod n (k-1) m) * n `mod` m
    | otherwise = t * t `mod` m
        where
            t = powMod n (k `quot` 2) m

invModWithFermat :: Int -> Int -> Int
invModWithFermat a m = powMod a (m - 2) m

solve :: Int -> Int -> Int -> Int
solve n a b = (n' - (na * a' `mod` m) - (nb * b' `mod` m) - 1) `mod` m
    where
        m = 10 ^ 9 + 7
        n' = ((powMod 2 n m) + m) `mod` m
        a' = invModWithFermat (VU.foldl' (\acc x -> x * acc `mod` m) 1 $ VU.fromList [1..a]) m
        b' = invModWithFermat (VU.foldl' (\acc x -> x * acc `mod` m) 1 $ VU.fromList [1..b]) m
        na = VU.foldl' (\acc x -> x * acc `mod` m) 1 $ VU.fromList [n, n-1..n-a+1]
        nb = VU.foldl' (\acc x -> x * acc `mod` m) 1 $ VU.fromList [n, n-1..n-b+1]

main = do
    [n,a,b] <- map read . words <$> getLine :: IO [Int]
    print $ max 0 (solve n a b)