import           Data.Bits
import qualified Data.ByteString.Char8 as BS
import           Data.Maybe

-- compulte a^n `mod` p                                                                                                                      
modpow :: Int -> Int -> Int -> Int
modpow a n p =
    let modpow' a n res | n == 0    = res
                        | otherwise =
                            modpow' (a*a`mod`p)
                                    (n `shiftR` 1)
                                    (if (n .&. 1) == 1 then res * a `mod` p else res)
    in modpow' a n 1

-- compute a^(-1) `mod` p                                                                                                                    
modinv :: Int -> Int -> Int
modinv a p = modpow a (p-2) p

readInt = fst . fromJust . BS.readInt
readIntList = map readInt . BS.words
getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine


main = do
  [n, a, b] <- getIntList

  let m = 10^9 + 7 :: Int

      fact i j | i == j = j
               | otherwise = i * fact (i-1) j `mod` m

      nCr n r = let num = fact n (n-r+1)
                    den = fact r 1
                in num * modinv den m `mod` m

      ans = (((modpow 2 n m - 1) `mod` m  - nCr n a) `mod` m  - nCr n b) `mod` m

  print ans