class Factorial():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
        self._factorial_inv = [1]
        self._size_inv = 1

    def __call__(self, n):
        return self.fact(n)

    def fact(self, n):
        ''' n! % mod '''
        if n >= self.mod:
            return 0
        self._make(n)
        return self._factorial[n]
    
    def _make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

    def fact_inv(self, n):
        ''' n!^-1 % mod '''
        if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        self._make(n)
        if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
        if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
        return self._factorial_inv[n]
    
    @staticmethod
    def xgcd(a, b):
        '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        '''
        x0, x1, y0, y1 = 0, 1, 1, 0
        while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
        return b, x0, y0

    def modinv(self, n):
        g, x, _ = self.xgcd(n, self.mod)
        if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        return x % self.mod

    def comb(self, n, r):
        ''' nCr % mod '''
        if r > n:
            return 0
        t = self(n)*self.fact_inv(n-r) % self.mod
        return t*self.fact_inv(r) % self.mod
    
    def comb_(self, n, r):
        '''
        nCr % mod
        when r is not large and n is too large
        '''
        c = 1
        for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
        return c

    def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        t = self(n+r-1)*self.fact_inv(n-1) % self.mod
        return t*self.fact_inv(r) % self.mod

    def perm(self, n, r):
        ''' nPr % mod '''
        if r > n:
            return 0
        return self(n)*self.fact_inv(n-r) % self.mod

mod = 10**9 + 7
n, a, b = map(int, input().split())
comb = Factorial().comb_
print((pow(2, n, mod) - comb(n, a) - comb(n, b) - 1) % mod) class Factorial():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
        self._factorial_inv = [1]
        self._size_inv = 1

    def __call__(self, n):
        return self.fact(n)

    def fact(self, n):
        ''' n! % mod '''
        if n >= self.mod:
            return 0
        self._make(n)
        return self._factorial[n]
    
    def _make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

    def fact_inv(self, n):
        ''' n!^-1 % mod '''
        if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        self._make(n)
        if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
        if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
        return self._factorial_inv[n]
    
    @staticmethod
    def xgcd(a, b):
        '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        '''
        x0, x1, y0, y1 = 0, 1, 1, 0
        while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
        return b, x0, y0

    def modinv(self, n):
        g, x, _ = self.xgcd(n, self.mod)
        if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        return x % self.mod

    def comb(self, n, r):
        ''' nCr % mod '''
        if r > n:
            return 0
        t = self(n)*self.fact_inv(n-r) % self.mod
        return t*self.fact_inv(r) % self.mod
    
    def comb_(self, n, r):
        '''
        nCr % mod
        when r is not large and n is too large
        '''
        c = 1
        for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
        return c

    def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        t = self(n+r-1)*self.fact_inv(n-1) % self.mod
        return t*self.fact_inv(r) % self.mod

    def perm(self, n, r):
        ''' nPr % mod '''
        if r > n:
            return 0
        return self(n)*self.fact_inv(n-r) % self.mod Factorial def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
        self._factorial_inv = [1]
        self._size_inv = 1

     __init__ self.mod = mod self.mod self mod mod self._factorial = [1] self._factorial self _factorial [1] 1 self._size = 1 self._size self _size 1 self._factorial_inv = [1] self._factorial_inv self _factorial_inv [1] 1 self._size_inv = 1 self._size_inv self _size_inv 1 self self mod=10**9 + 7 mod 10**9 + 7 10**9 10 9 7 def __call__(self, n):
        return self.fact(n)

     __call__ return self.fact(n) self.fact(n) self.fact self fact n self self n n def fact(self, n):
        ''' n! % mod '''
        if n >= self.mod:
            return 0
        self._make(n)
        return self._factorial[n]
    
     fact ''' n! % mod ''' if n >= self.mod:
            return 0
         n >= self.mod n self.mod self mod return 0 0 self._make(n) self._make self _make n return self._factorial[n] self._factorial[n] self._factorial self _factorial n self self n n def _make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

     _make if n >= self.mod:
            n = self.mod
         n >= self.mod n self.mod self mod n = self.mod n self.mod self mod if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

     self._size < n+1 self._size self _size n+1 n 1 for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
             i range(self._size, n+1) range self._size self _size n+1 n 1 self._factorial.append(self._factorial[i-1]*i % self.mod) self._factorial.append self._factorial self _factorial append self._factorial[i-1]*i % self.mod self._factorial[i-1]*i self._factorial[i-1] self._factorial self _factorial i-1 i 1 i self.mod self mod self._size = n+1 self._size self _size n+1 n 1 self self n n def fact_inv(self, n):
        ''' n!^-1 % mod '''
        if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        self._make(n)
        if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
        if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
        return self._factorial_inv[n]
    
     fact_inv ''' n!^-1 % mod ''' if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
         n >= self.mod n self.mod self mod raise ValueError('Modinv is not exist! arg={}'.format(n)) ValueError('Modinv is not exist! arg={}'.format(n)) ValueError 'Modinv is not exist! arg={}'.format(n) 'Modinv is not exist! arg={}'.format 'Modinv is not exist! arg={}' format n self._make(n) self._make self _make n if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
         self._size_inv < n+1 self._size_inv self _size_inv n+1 n 1 self._factorial_inv += [-1] * (n+1-self._size_inv) self._factorial_inv self _factorial_inv [-1] * (n+1-self._size_inv) [-1] -1 n+1-self._size_inv n+1 n 1 self._size_inv self _size_inv self._size_inv = n+1 self._size_inv self _size_inv n+1 n 1 if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
         self._factorial_inv[n] == -1 self._factorial_inv[n] self._factorial_inv self _factorial_inv n -1 self._factorial_inv[n] = self.modinv(self._factorial[n]) self._factorial_inv[n] self._factorial_inv self _factorial_inv n self.modinv(self._factorial[n]) self.modinv self modinv self._factorial[n] self._factorial self _factorial n return self._factorial_inv[n] self._factorial_inv[n] self._factorial_inv self _factorial_inv n self self n n def xgcd(a, b):
        '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        '''
        x0, x1, y0, y1 = 0, 1, 1, 0
        while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
        return b, x0, y0

     xgcd '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        ''' x0, x1, y0, y1 = 0, 1, 1, 0 x0 0 x1 1 y0 1 y1 0 while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
         a != 0 a 0 (q, a), b = divmod(b, a), a (q, a) q a divmod(b, a) divmod b a b a y0, y1 = y1, y0 - q * y1 y0 y1 y1 y0 - q * y1 y0 q * y1 q y1 x0, x1 = x1, x0 - q * x1 x0 x1 x1 x0 - q * x1 x0 q * x1 q x1 return b, x0, y0 return b, x0, y0 b x0 y0 a a b b @staticmethod
     xgcd staticmethod xgcd def modinv(self, n):
        g, x, _ = self.xgcd(n, self.mod)
        if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        return x % self.mod

     modinv g, x, _ = self.xgcd(n, self.mod) g self.xgcd(n, self.mod) self.xgcd self xgcd n self.mod self mod x _ if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
         g != 1 g 1 raise ValueError('Modinv is not exist! arg={}'.format(n)) ValueError('Modinv is not exist! arg={}'.format(n)) ValueError 'Modinv is not exist! arg={}'.format(n) 'Modinv is not exist! arg={}'.format 'Modinv is not exist! arg={}' format n return x % self.mod x % self.mod x self.mod self mod self self n n def comb(self, n, r):
        ''' nCr % mod '''
        if r > n:
            return 0
        t = self(n)*self.fact_inv(n-r) % self.mod
        return t*self.fact_inv(r) % self.mod
    
     comb ''' nCr % mod ''' if r > n:
            return 0
         r > n r n return 0 0 t = self(n)*self.fact_inv(n-r) % self.mod t self(n)*self.fact_inv(n-r) % self.mod self(n)*self.fact_inv(n-r) self(n) self n self.fact_inv(n-r) self.fact_inv self fact_inv n-r n r self.mod self mod return t*self.fact_inv(r) % self.mod t*self.fact_inv(r) % self.mod t*self.fact_inv(r) t self.fact_inv(r) self.fact_inv self fact_inv r self.mod self mod self self n n r r def comb_(self, n, r):
        '''
        nCr % mod
        when r is not large and n is too large
        '''
        c = 1
        for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
        return c

     comb_ '''
        nCr % mod
        when r is not large and n is too large
        ''' c = 1 c 1 for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
         i range(1, r+1) range 1 r+1 r 1 c *= (n-i+1) * self.modinv(i) c (n-i+1) * self.modinv(i) n-i+1 n-i n i 1 self.modinv(i) self.modinv self modinv i c %= self.mod c self.mod self mod return c c self self n n r r def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        t = self(n+r-1)*self.fact_inv(n-1) % self.mod
        return t*self.fact_inv(r) % self.mod

     comb_with_repetition ''' nHr % mod ''' t = self(n+r-1)*self.fact_inv(n-1) % self.mod t self(n+r-1)*self.fact_inv(n-1) % self.mod self(n+r-1)*self.fact_inv(n-1) self(n+r-1) self n+r-1 n+r n r 1 self.fact_inv(n-1) self.fact_inv self fact_inv n-1 n 1 self.mod self mod return t*self.fact_inv(r) % self.mod t*self.fact_inv(r) % self.mod t*self.fact_inv(r) t self.fact_inv(r) self.fact_inv self fact_inv r self.mod self mod self self n n r r def perm(self, n, r):
        ''' nPr % mod '''
        if r > n:
            return 0
        return self(n)*self.fact_inv(n-r) % self.mod perm ''' nPr % mod ''' if r > n:
            return 0
         r > n r n return 0 0 return self(n)*self.fact_inv(n-r) % self.mod self(n)*self.fact_inv(n-r) % self.mod self(n)*self.fact_inv(n-r) self(n) self n self.fact_inv(n-r) self.fact_inv self fact_inv n-r n r self.mod self mod self self n n r r mod = 10**9 + 7 mod 10**9 + 7 10**9 10 9 7 n, a, b = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split a b comb = Factorial().comb_ comb Factorial().comb_ () Factorial comb_ print((pow(2, n, mod) - comb(n, a) - comb(n, b) - 1) % mod) print (pow(2, n, mod) - comb(n, a) - comb(n, b) - 1) % mod pow(2, n, mod) - comb(n, a) - comb(n, b) - 1 pow(2, n, mod) - comb(n, a) - comb(n, b) pow(2, n, mod) - comb(n, a) pow(2, n, mod) pow 2 n mod comb(n, a) comb n a comb(n, b) comb n b 1 mod b = map(int, input().split()) map(int, input().split()) b n, a, b = map(int, input().split()) map(int, input().split()) n a, b = map(int, input().split()) map(int, input().split()) a comb = Factorial().comb_ Factorial().comb_ comb class Factorial():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
        self._factorial_inv = [1]
        self._size_inv = 1

    def __call__(self, n):
        return self.fact(n)

    def fact(self, n):
        ''' n! % mod '''
        if n >= self.mod:
            return 0
        self._make(n)
        return self._factorial[n]
    
    def _make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

    def fact_inv(self, n):
        ''' n!^-1 % mod '''
        if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        self._make(n)
        if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
        if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
        return self._factorial_inv[n]
    
    @staticmethod
    def xgcd(a, b):
        '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        '''
        x0, x1, y0, y1 = 0, 1, 1, 0
        while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
        return b, x0, y0

    def modinv(self, n):
        g, x, _ = self.xgcd(n, self.mod)
        if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        return x % self.mod

    def comb(self, n, r):
        ''' nCr % mod '''
        if r > n:
            return 0
        t = self(n)*self.fact_inv(n-r) % self.mod
        return t*self.fact_inv(r) % self.mod
    
    def comb_(self, n, r):
        '''
        nCr % mod
        when r is not large and n is too large
        '''
        c = 1
        for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
        return c

    def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        t = self(n+r-1)*self.fact_inv(n-1) % self.mod
        return t*self.fact_inv(r) % self.mod

    def perm(self, n, r):
        ''' nPr % mod '''
        if r > n:
            return 0
        return self(n)*self.fact_inv(n-r) % self.mod class Factorial():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
        self._factorial_inv = [1]
        self._size_inv = 1

    def __call__(self, n):
        return self.fact(n)

    def fact(self, n):
        ''' n! % mod '''
        if n >= self.mod:
            return 0
        self._make(n)
        return self._factorial[n]
    
    def _make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

    def fact_inv(self, n):
        ''' n!^-1 % mod '''
        if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        self._make(n)
        if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
        if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
        return self._factorial_inv[n]
    
    @staticmethod
    def xgcd(a, b):
        '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        '''
        x0, x1, y0, y1 = 0, 1, 1, 0
        while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
        return b, x0, y0

    def modinv(self, n):
        g, x, _ = self.xgcd(n, self.mod)
        if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        return x % self.mod

    def comb(self, n, r):
        ''' nCr % mod '''
        if r > n:
            return 0
        t = self(n)*self.fact_inv(n-r) % self.mod
        return t*self.fact_inv(r) % self.mod
    
    def comb_(self, n, r):
        '''
        nCr % mod
        when r is not large and n is too large
        '''
        c = 1
        for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
        return c

    def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        t = self(n+r-1)*self.fact_inv(n-1) % self.mod
        return t*self.fact_inv(r) % self.mod

    def perm(self, n, r):
        ''' nPr % mod '''
        if r > n:
            return 0
        return self(n)*self.fact_inv(n-r) % self.mod Factorial mod = 10**9 + 7 10**9 + 7 mod
class Factorial():
    def __init__(self, mod=10**9 + 7):
        self.mod = mod
        self._factorial = [1]
        self._size = 1
        self._factorial_inv = [1]
        self._size_inv = 1

    def __call__(self, n):
        return self.fact(n)

    def fact(self, n):
        ''' n! % mod '''
        if n >= self.mod:
            return 0
        self._make(n)
        return self._factorial[n]
    
    def _make(self, n):
        if n >= self.mod:
            n = self.mod
        if self._size < n+1:
            for i in range(self._size, n+1):
                self._factorial.append(self._factorial[i-1]*i % self.mod)
            self._size = n+1

    def fact_inv(self, n):
        ''' n!^-1 % mod '''
        if n >= self.mod:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        self._make(n)
        if self._size_inv < n+1:
            self._factorial_inv += [-1] * (n+1-self._size_inv)
            self._size_inv = n+1
        if self._factorial_inv[n] == -1:
            self._factorial_inv[n] = self.modinv(self._factorial[n])
        return self._factorial_inv[n]
    
    @staticmethod
    def xgcd(a, b):
        '''
        Return (gcd(a, b), x, y) such that a*x + b*y = gcd(a, b)
        '''
        x0, x1, y0, y1 = 0, 1, 1, 0
        while a != 0:
            (q, a), b = divmod(b, a), a
            y0, y1 = y1, y0 - q * y1
            x0, x1 = x1, x0 - q * x1
        return b, x0, y0

    def modinv(self, n):
        g, x, _ = self.xgcd(n, self.mod)
        if g != 1:
            raise ValueError('Modinv is not exist! arg={}'.format(n))
        return x % self.mod

    def comb(self, n, r):
        ''' nCr % mod '''
        if r > n:
            return 0
        t = self(n)*self.fact_inv(n-r) % self.mod
        return t*self.fact_inv(r) % self.mod
    
    def comb_(self, n, r):
        '''
        nCr % mod
        when r is not large and n is too large
        '''
        c = 1
        for i in range(1, r+1):
            c *= (n-i+1) * self.modinv(i)
            c %= self.mod
        return c

    def comb_with_repetition(self, n, r):
        ''' nHr % mod '''
        t = self(n+r-1)*self.fact_inv(n-1) % self.mod
        return t*self.fact_inv(r) % self.mod

    def perm(self, n, r):
        ''' nPr % mod '''
        if r > n:
            return 0
        return self(n)*self.fact_inv(n-r) % self.mod

mod = 10**9 + 7
n, a, b = map(int, input().split())
comb = Factorial().comb_
print((pow(2, n, mod) - comb(n, a) - comb(n, b) - 1) % mod)