import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Text.Read as T
import qualified Data.Vector.Unboxed as VU

main :: IO ()
main = do
  (n : a : b : _) <- map unsafeTextToInt . T.words <$> T.getLine :: IO [Int]
  let
    comb = modComb n
  print . (`mod` modulus) $ modExp 2 n - 1 - comb a - comb b

modExp :: Integral a => Int -> a -> Int
modExp = exp' 1
  where
    exp' z _ 0 = z
    exp' z w y = exp' z' w' y'
      where
        y' = y `div` 2
        w' = w * w `mod` modulus
        z' | even y    = z
           | otherwise = (z * w) `mod` modulus

modInv :: Int -> Int
modInv = (invs VU.!)
  where
    invs :: VU.Vector Int
    invs = VU.constructN (succ $ 2 * 10 ^ 5) rec
      where
        rec v = case VU.length v of
          0 -> 0
          1 -> 1
          l -> let (q, r) = modulus `divMod` l in (modulus - (v VU.! r) * q) `mod` modulus

modComb :: Int -> Int -> Int
modComb n = (combs VU.!)
  where
    combs = VU.unfoldrN (succ $ 2 * 10 ^ 5) next (0, 0)
      where
        next (0, _) = Just (1, (1, 1))
        next (k, x) = let x' = (((x * (n - k + 1)) `mod` modulus) * modInv k) `mod` modulus in Just (x', (succ k, x'))

modulus :: Int
modulus = 10 ^ 9 + 7

unsafeTextToInt :: T.Text -> Int
unsafeTextToInt s = case T.signed T.decimal s of
  Right (n, _) -> n
