import Control.Monad
import Data.Maybe
import qualified Data.ByteString.Char8 as BS
import Data.List
import qualified Data.Vector as V

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

moduloN :: Int
moduloN = 10 ^ 9 + 7

modN = flip mod moduloN

finv :: Int -> Int
finv n = finvs V.! n
    where finvs :: V.Vector Int
          finvs = V.generate (10 ^ 9 + 1) finv'
              where finv' 0 = 1
                    finv' n = modN $ finvs V.! (n - 1) * inv n

inv :: Int -> Int
inv n = invs V.! n
    where inv' 1 = 1
          inv' n = modN (-(invs V.! r) * q)
              where (q, r) = moduloN `divMod` n
          invs :: V.Vector Int
          invs = V.generate (10 ^ 9 + 1) inv'

fact :: Int -> Int
fact n = facts V.! n
    where fact' 0 = 1
          fact' n = modN $ n * (facts V.! (n - 1))
          facts :: V.Vector Int
          facts = V.generate (10 ^ 9 + 1) fact'

c :: Int -> Int -> Int
c n k | n < 0 || k < 0 || n < k = 0
      | otherwise = modN $ modN (fact n * finv k) * finv (n - k)

mulMod x y = modN $ x * y

powerMod x 0 = 1
powerMod x y
    | even y = mulMod t t
    | otherwise = mulMod x $ mulMod t t
    where
        t = powerMod x $ div y 2

comb n r = modN $ iterate (scanl1 (+)) [1, 1..] !! (n - r) !! r

main = do
    [n, a, b] <- getIntList
    print . modN $ (powerMod 2 n) + 2 * moduloN - (comb n a) - (comb n b)
