output_description: Print the number of bouquets that Akari can make, modulo (10^9 + 7). (If there
  are no such bouquets, print `0`.)
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      n a b
attempt: class Mint:
  
      MOD = 10**9 + 7
  
      def __init__(self, x=0):
          self.x = (x % self.MOD + self.MOD) % self.MOD
  
      def __iadd__(self, other):
          self.x += other.x
          if self.x >= self.MOD:
              self.x -= self.MOD
          return self
  
      def __isub__(self, other):
          self.x += self.MOD - other.x
          if self.x >= self.MOD:
              self.x -= self.MOD
          return self
  
      def __imul__(self, other):
          self.x *= other.x
          self.x %= self.MOD
          return self
  
      def __add__(self, other):
          ans = Mint(self.x)
          ans += other
          return ans
  
      def __sub__(self, other):
          ans = Mint(self.x)
          ans -= other
          return ans
  
      def __mul__(self, other):
          ans = Mint(self.x)
          ans *= other
          return ans
  
      def __pow__(self, n):
          if n == 0:
              return Mint(1)
          a = self.__pow__(n >> 1)
          a *= a
          if n & 1:
              a *= self
          return a
  
      def inv(self):
          return self ** (self.MOD - 2)
  
      def __ifloordiv__(self, other):
          self *= other.inv()
          return self
  
      def __floordiv__(self, other):
          ans = Mint(self.x)
          ans //= other
          return ans
  
  
  class Comb:
  
      def __init__(self):
          pass
  
      def comb(self, n, k):
          assert n < Mint.MOD
          if k < 0 or k > n:
              return 0
          numerator = Mint(n - k + 1)
          for i in range(n - k + 2, n + 1):
              numerator *= Mint(i)
          d = Mint(1)
          for i in range(2, k + 1):
              d *= Mint(i)
          denominator = d.inv()
          return numerator * denominator
  
  
  def Main(N, A, B):
      ans = Mint(2) ** N - Mint(1) - Comb().comb(N, A) - Comb().comb(N, B)
      return ans.x
  
  
  def main():
      N, A, B = list(map(int, input().split()))
      print(Main(N, A, B))
  
  
  if __name__ == "__main__":
      main()
  
problem_description: 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.
samples: [{"input": "4 1 3", "output": "7\n    \n\nIn this case, Akari can choose 2 or 4 flowers to make the bouquet.\n\nThere are 6 ways to choose 2 out of the 4 flowers, and 1 way to choose 4, so\nthere are a total of 7 different bouquets that Akari can make.\n\n* * *"}, {"input": "1000000000 141421 173205", "output": "34076506\n    \n\nPrint the count modulo (10^9 + 7)."}]