n, a, b = map(int, input().split())

MOD = 10 ** 9 + 7

class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0

c = Factorial(max(a, b) + 1, MOD)

def combination(n, r): #nCrを求める
    if n - r < r:
        r = n - r
    tmp = 1
    for i in range(n - r + 1, n + 1):
        tmp *= i
        tmp %= MOD
    tmp *= c.ifactorial(r)
    return tmp

MOD = 10 ** 9 + 7


ans = pow(2, n, MOD) - 1 #選ばないのを除く

ans -= combination(n, a)
ans %= MOD
ans -= combination(n, b)
ans %= MOD

print (ans) n, a, b = map(int, input().split()) n map(int, input().split()) map int input().split() ().split () input split a b MOD = 10 ** 9 + 7 MOD 10 ** 9 + 7 10 ** 9 10 9 7 class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 Factorial def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
     __init__ self.f = [1] self.f self f [1] 1 self.mod = mod self.mod self mod mod for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
         j range(1, n + 1) range 1 n + 1 n 1 self.f.append(self.f[-1] * j % mod) self.f.append self.f self f append self.f[-1] * j % mod self.f[-1] * j self.f[-1] self.f self f -1 j mod self.i = [pow(self.f[-1], mod - 2, mod)] self.i self i [pow(self.f[-1], mod - 2, mod)] pow(self.f[-1], mod - 2, mod) pow self.f[-1] self.f self f -1 mod - 2 mod 2 mod for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
         j range(n, 0, -1) range n 0 -1 self.i.append(self.i[-1] * j % mod) self.i.append self.i self i append self.i[-1] * j % mod self.i[-1] * j self.i[-1] self.i self i -1 j mod self.i.reverse() self.i.reverse self.i self i reverse self self n n mod mod def factorial(self, j):
        return self.f[j]
     factorial return self.f[j] self.f[j] self.f self f j self self j j def ifactorial(self, j):
        return self.i[j]
     ifactorial return self.i[j] self.i[j] self.i self i j self self j j def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 comb return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 n >= k n k self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod self.f[n] * self.i[n - k] % self.mod * self.i[k] self.f[n] * self.i[n - k] % self.mod self.f[n] * self.i[n - k] self.f[n] self.f self f n self.i[n - k] self.i self i n - k n k self.mod self mod self.i[k] self.i self i k self.mod self mod 0 self self n n k k c = Factorial(max(a, b) + 1, MOD) c Factorial(max(a, b) + 1, MOD) Factorial max(a, b) + 1 max(a, b) max a b 1 MOD def combination(n, r): #nCrを求める
    if n - r < r:
        r = n - r
    tmp = 1
    for i in range(n - r + 1, n + 1):
        tmp *= i
        tmp %= MOD
    tmp *= c.ifactorial(r)
    return tmp combination if n - r < r:
        r = n - r
     n - r < r n - r n r r r = n - r r n - r n r tmp = 1 tmp 1 for i in range(n - r + 1, n + 1):
        tmp *= i
        tmp %= MOD
     i range(n - r + 1, n + 1) range n - r + 1 n - r n r 1 n + 1 n 1 tmp *= i tmp i tmp %= MOD tmp MOD tmp *= c.ifactorial(r) tmp c.ifactorial(r) c.ifactorial c ifactorial r return tmp tmp n n r r MOD = 10 ** 9 + 7 MOD 10 ** 9 + 7 10 ** 9 10 9 7 ans = pow(2, n, MOD) - 1 ans pow(2, n, MOD) - 1 pow(2, n, MOD) pow 2 n MOD 1 ans -= combination(n, a) ans combination(n, a) combination n a ans %= MOD ans MOD ans -= combination(n, b) ans combination(n, b) combination n b ans %= MOD ans MOD print (ans) print ans ans -= combination(n, a) combination(n, a) ans ans -= combination(n, b) combination(n, b) ans a, b = map(int, input().split()) map(int, input().split()) a MOD = 10 ** 9 + 7 10 ** 9 + 7 MOD def combination(n, r): #nCrを求める
    if n - r < r:
        r = n - r
    tmp = 1
    for i in range(n - r + 1, n + 1):
        tmp *= i
        tmp %= MOD
    tmp *= c.ifactorial(r)
    return tmp def combination(n, r): #nCrを求める
    if n - r < r:
        r = n - r
    tmp = 1
    for i in range(n - r + 1, n + 1):
        tmp *= i
        tmp %= MOD
    tmp *= c.ifactorial(r)
    return tmp combination ans %= MOD MOD ans MOD = 10 ** 9 + 7 10 ** 9 + 7 MOD class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0 Factorial c = Factorial(max(a, b) + 1, MOD) Factorial(max(a, b) + 1, MOD) c ans %= MOD MOD ans ans = pow(2, n, MOD) - 1 pow(2, n, MOD) - 1 ans b = map(int, input().split()) map(int, input().split()) b n, a, b = map(int, input().split()) map(int, input().split()) n
n, a, b = map(int, input().split())

MOD = 10 ** 9 + 7

class Factorial:
    def __init__(self, n, mod):
        self.f = [1]
        self.mod = mod
        for j in range(1, n + 1):
            self.f.append(self.f[-1] * j % mod)
        self.i = [pow(self.f[-1], mod - 2, mod)]
        for j in range(n, 0, -1):
            self.i.append(self.i[-1] * j % mod)
        self.i.reverse()
    def factorial(self, j):
        return self.f[j]
    def ifactorial(self, j):
        return self.i[j]
    def comb(self, n, k):
        return self.f[n] * self.i[n - k] % self.mod * self.i[k] % self.mod if n >= k else 0

c = Factorial(max(a, b) + 1, MOD)

def combination(n, r): #nCrを求める
    if n - r < r:
        r = n - r
    tmp = 1
    for i in range(n - r + 1, n + 1):
        tmp *= i
        tmp %= MOD
    tmp *= c.ifactorial(r)
    return tmp

MOD = 10 ** 9 + 7


ans = pow(2, n, MOD) - 1 #選ばないのを除く

ans -= combination(n, a)
ans %= MOD
ans -= combination(n, b)
ans %= MOD

print (ans)