CodeEff/ECCO huggingface dataset:
# Original solution
def main():
    #input data
    import sys
    input = lambda:sys.stdin.readline().strip()
    
    N,A,B = list(map(int,input().split()))
    mod=10**9+7
    #solve
    #二項係数の和=2**n
    #2**n-1-nCa-nCb
    def modinv(a, mod=10**9+7):
        return pow(a, mod-2, mod)
    def cmb(n, r, mod=10**9+7):
        r = min(r, n-r)
        res = 1
        for i in range(r):
            res = res * (n - i) * modinv(i+1, mod) % mod
        return res
                
    ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
    print((ans%mod))

if __name__=='__main__':
    main()

# Optimized solution
def main():
    #input data
    import sys
    input = lambda:sys.stdin.readline().strip()
    
    N,A,B = list(map(int,input().split()))
    mod=10**9+7
    #solve
    #二項係数の和=2**n
    #2**n-1-nCa-nCb
    def cmb(n, r, mod=10**9+7):
        r = min(r, n-r)
        res = 1
        for i in range(r):
            res = res * (n - i) * pow(i+1, mod-2, mod) % mod
        return res
                
    ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
    print((ans%mod))

if __name__=='__main__':
    main()
# Original solution
def main():
    #input data
    import sys
    input = lambda:sys.stdin.readline().strip()
    
    N,A,B = list(map(int,input().split()))
    mod=10**9+7
    #solve
    #二項係数の和=2**n
    #2**n-1-nCa-nCb
    def cmb(n, r, mod=10**9+7):
        r = min(r, n-r)
        res = 1
        for i in range(r):
            res = res * (n - i) * pow(i+1, mod-2, mod) % mod
        return res
                
    ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
    print((ans%mod))

if __name__=='__main__':
    main()

# Optimized solution
def main():
    #input data
    import sys
    input = lambda:sys.stdin.readline().strip()
    
    N,A,B = list(map(int,input().split()))
    mod=10**9+7
    #solve
    #二項係数の和=2**n
    #2**n-1-nCa-nCb
    
    def cmb(n, r, mod=10**9+7):
        c = 1
        m = 1
        r = min(n - r, r)
        for i in range(r):
            c = c * (n - i) % mod
            m = m * (i + 1) % mod
        return c * pow(m, mod - 2, mod) % mod
                
    ans = pow(2,N,mod)-1-cmb(N,A,mod)-cmb(N,B,mod)
    print((ans%mod))

if __name__=='__main__':
    main()
# Original solution
n, a, b = list(map(int, input().split()))
mod = 10**9+7


def extgcd(a, b):
    r = [1, 0, a]
    w = [0, 1, b]
    while w[2] != 1:
        q = r[2]//w[2]
        r2 = w
        w2 = [r[0]-q*w[0], r[1]-q*w[1], r[2]-q*w[2]]
        r = r2
        w = w2
    # [x,y]
    return [w[0], w[1]]


def mod_inv(a, m):
    x = extgcd(a, m)[0]
    return (m+x % m) % m


def comb(n, r, mod):
    u = 1
    d = 1
    for i in range(r):
        u *= n-i
        d *= i+1
        if u >= mod:
            u %= mod
        if d >= mod:
            d %= mod
    return u*mod_inv(d, mod)


def binary(n):
    return bin(n)[2:]


def pow_by_binary_exponentiation(a, x, n):  # a^x mod n
    x = [int(b) for b in binary(x)]
    y = a
    for i in range(1, len(x)):
        y = (y**2) % n
        if x[i] == 1:
            y = (y * a) % n
    return y


ac = comb(n, a, mod)
bc = comb(n, b, mod)
ans = pow_by_binary_exponentiation(2, n, mod)
print((((ans - ac - bc - 1) % mod)//1))


# Optimized solution
n, a, b = list(map(int, input().split()))
mod = 10**9+7


def binary(n):
    return bin(n)[2:]


# a^x mod n : ans = pow_by_binary_exponentiation(2, 1000, 10**9+7)
def pow_by_binary_exponentiation(a, x, n):
    x = [int(b) for b in binary(x)]
    y = a
    for i in range(1, len(x)):
        y = (y**2) % n
        if x[i] == 1:
            y = (y * a) % n
    return y


def combination(n, r, mod=10**9+7):
    n1, r = n+1, min(r, n-r)
    numer = denom = 1
    for i in range(1, r+1):
        numer = numer * (n1-i) % mod
        denom = denom * i % mod
    return numer * pow(denom, mod-2, mod) % mod


ac = combination(n, a, mod)
bc = combination(n, b, mod)
ans = pow_by_binary_exponentiation(2, n, mod)
print((((ans - ac - bc - 1) % mod)//1))
# Original solution
from functools import reduce

N, A, B = list(map(int, input().split()))

MOD = 10 ** 9 + 7

def f(A):
    num = reduce(lambda x, y: x * y % MOD, list(range(N, N - A, -1)))
    den = reduce(lambda x, y: x * y % MOD, list(range(1, A + 1)))
    return num * pow(den, MOD - 2, MOD) % MOD

answer = pow(2, N, MOD) - 1 - f(A) - f(B)
answer %= MOD
print(answer)

# Optimized solution
from functools import reduce

def combinations_count_mod(n, r, m):
    num = reduce(lambda x, y: x * y % m, list(range(n, n - r, -1)))
    den = reduce(lambda x, y: x * y % m, list(range(1, r + 1)))
    return num * pow(den, m - 2, m) % m

N, A, B = list(map(int, input().split()))

MOD = 10 ** 9 + 7
 
answer = pow(2, N, MOD) - 1 - combinations_count_mod(N, A, MOD) - combinations_count_mod(N, B, MOD)
answer %= MOD
print(answer)
# Original solution
n,a,b=list(map(int,input().split()))
mod=10**9+7

def comb(n,r,mod):
    p,q=1,1
    for i in range(r):
        p=p*(n-i)%mod 
        q=q*(i+1)%mod 
    return p*pow(q,mod-2,mod)%mod

nca=comb(n,a,mod)
ncb=comb(n,b,mod)

ans=pow(2,n,mod)
ans=(ans-((nca+ncb)%mod+1))%mod
print(ans)

# Optimized solution
n,a,b=list(map(int,input().split()))
mod=10**9+7

def comb(n,r,mod):
    p,q=1,1
    for i in range(min(r,n-r)):
        p=p*(n-i)%mod 
        q=q*(i+1)%mod 
    return p*pow(q,mod-2,mod)%mod

nca=comb(n,a,mod)
ncb=comb(n,b,mod)

ans=pow(2,n,mod)
ans=(ans-((nca+ncb)%mod+1))%mod
print(ans)
# Original solution
def main():
    mod = 10 ** 9 + 7

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

    ma = max(a, b)
    tbl = [0] * (ma + 1)

    # f = 1
    # for i in range(1, ma + 1):
    #     f = (f * i) % mod
    #
    # invs = [1] * (ma + 1)
    # invs[ma] = pow(f, mod - 2, mod)
    # for x in range(ma - 1, 0, -1):
    #     invs[x] = invs[x + 1] * (x + 1) % mod

    t = 1
    for i in range(1, max(a, b) + 1):
        t = (t * (n - i + 1) * pow(i, mod - 2, mod)) % mod
        tbl[i] = t

    ans = pow(2, n, mod) - 1 - tbl[a] - tbl[b]
    print((ans % mod))


if __name__ == '__main__':
    main()


# Optimized solution
mod = 10 ** 9 + 7

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


def choose(n, a, mod=mod):
    x, y = 1, 1
    for i in range(a):
        x = x * (n - i) % mod
        y = y * (i + 1) % mod
    return x * pow(y, mod - 2, mod)


ret = pow(2, n, mod)
ret -= 1
ret -= choose(n, a)
ret -= choose(n, b)
ret %= mod

print(ret)
# Original solution
n,a,b=list(map(int,input().split()))
mod=(10**9)+7
ans=pow(2,n,mod)-1
comb=1
for i in range(n-a+1,n+1):
    comb*=i
    comb%=mod
for i in range(1,a+1):
    comb*=pow(i,mod-2,mod)
    comb%=mod
comb2=1
for i in range(n-b+1,n+1):
    comb2*=i
    comb2%=mod
for i in range(1,b+1):
    comb2*=pow(i,mod-2,mod)
    comb2%=mod
ans=ans-comb-comb2
ans%=mod
print(ans)

# Optimized solution
def main():
    n,a,b=list(map(int,input().split()))
    mod=(10**9)+7
    ans=pow(2,n,mod)-1
    comb=1
    for i in range(n-a+1,n+1):
        comb*=i
        comb%=mod
    for i in range(1,a+1):
        comb*=pow(i,mod-2,mod)
        comb%=mod
    comb2=1
    for i in range(n-b+1,n+1):
        comb2*=i
        comb2%=mod
    for i in range(1,b+1):
        comb2*=pow(i,mod-2,mod)
        comb2%=mod
    ans=ans-comb-comb2
    ans%=mod
    print(ans)

if __name__=="__main__":
    main()
# Original solution
n,a,b = [int(x) for x in input().split()]

ans = 0
mod = 10**9+7
ans = (pow(2,n,mod)-1)%mod

com1 = 1
for i in range(n-a+1,n+1):
    com1 = com1*i%mod
for i in range(1,a+1):
    com1 = com1 * pow(i,mod-2,mod)%mod
com2 = 1
for i in range(n-b+1,n+1):
    com2 = com2*i%mod
for i in range(1,b+1):
    com2 = com2*pow(i,mod-2,mod)%mod
ans = (ans - com1 - com2)%mod
print(ans)

# Optimized solution
n,a,b = [int(x) for x in input().split()]

ans = 0
mod = 10**9+7
ans = (pow(2,n,mod)-1)%mod

com1 = 1
for i in range(n-a+1,n+1):
    com1 = com1*i%mod
for i in range(1,a+1):
    com1 = com1 * pow(i,mod-2,mod)%mod
com2 = 1
for i in range(n-b+1,n+1):
    com2 = com2*i%mod
x = 1
for i in range(1,b+1):
    x = x*i%mod
com2 = com2*pow(x,mod-2,mod)%mod

ans = (ans - com1 - com2)%mod
print(ans)
# Original solution
n,a,b = list(map(int,input().split()))
m = 10**9 + 7
comb_a = 1
comb_b = 1

a_num = list(range(1,a+1))
j = 0
for i in range(1,a+1):
    comb_a *= (n-i+1)
    comb_a *= pow(a_num[i-1],m-2,m)
    comb_a = comb_a % m

b_num = list(range(1,b+1))
j = 0
for i in range(1,b+1):
    comb_b *= (n-i+1)
    comb_b *= pow(b_num[i-1],m-2,m)
    comb_b = comb_b % m

ans = pow(2,n,m) - comb_a - comb_b - 1
print((int(ans) % m))

# Optimized solution
def comb_mod(n,r,m):
    ans = 1
    for i in range(1,r+1):
        ans *= (n-i+1) % m
        ans *= pow(i,m-2,m) % m
        ans = ans % m
    return ans
n,a,b = list(map(int,input().split()))
m = 10**9 + 7
ans = pow(2,n,m) - comb_mod(n,a,m) - comb_mod(n,b,m) - 1
print((int(ans) % m))
# Original solution
def modpow(a,n,mod=10**9+7):
    res=1
    while n>0:
        if n&1:
            res=res*a%mod
        a=a*a%mod
        n>>=1
    return res%mod

def modcmb(n,r,mod=10**9+7):
    res=1
    div=min(r,n-r)
    for i in range(div):
        res=res*(n-i)*modpow(div-i,mod-2)%mod
    return res%mod

n,a,b=[int(i) for i in input().split()]
ans=modpow(2,n)-1
ans-=modcmb(n,a)
ans%=10**9+7
ans-=modcmb(n,b)
ans%=10**9+7
print(ans)

# Optimized solution
def modcmb(n,r,mod=10**9+7):
    res=1
    div=min(r,n-r)
    for i in range(div):
        res=res*(n-i)*pow(div-i,mod-2,mod)%mod
    return res%mod

n,a,b=[int(i) for i in input().split()]
mod=10**9+7
ans=pow(2,n,mod)-1
ans-=modcmb(n,a)
ans%=mod
ans-=modcmb(n,b)
ans%=mod
print(ans)
# Original solution
n, a, b = list(map(int,input().split()))
MOD = 10**9 + 7
ans = pow(2,n,MOD)-1

def cmb(n, r):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])
            result %= MOD

    return result
ans -= (cmb(n,a) + cmb(n,b))
print((ans%MOD))


# Optimized solution
MOD = 10**9 + 7
def nCr(n, r, MOD):
    if n - r < r: r = n - r
    if r == 0: return 1
    if r == 1: return n

    numerator = [n - r + k + 1 for k in range(r)]
    denominator = [k + 1 for k in range(r)]

    for p in range(2,r+1):
        pivot = denominator[p - 1]
        if pivot > 1:
            offset = (n - r) % p
            for k in range(p-1,r,p):
                numerator[k - offset] /= pivot
                denominator[k] /= pivot

    result = 1
    for k in range(r):
        if numerator[k] > 1:
            result *= int(numerator[k])
            result %= MOD

    return result
n, a, b = list(map(int,input().split()))
ans = pow(2,n,MOD)-1-nCr(n,a,MOD)-nCr(n,b,MOD)
while ans < 0:
    ans += MOD
print(ans)
# Original solution
n,a,b = list(map(int,input().split()))
mod = 10 ** 9 + 7

# 乗法のmod逆元 (mod-2乗)
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    res = 1
    for i in range(r):
        res = res * (n - i) * modinv(i+1, mod) % mod
    return res

ans = pow(2, n, mod)
ans -= combination(n,a) + combination(n,b) + 1

print((ans % mod))


# Optimized solution
n,a,b = list(map(int,input().split()))
mod = 10 ** 9 + 7

# 乗法のmod逆元 (mod-2乗)
def modinv(a, mod=10**9+7):
    return pow(a, mod-2, mod)

# nCr mod m
# modinvが必要
# rがn/2に近いと非常に重くなる
def combination(n, r, mod=10**9+7):
    r = min(r, n-r)
    x = 1
    y = 1
    for i in range(r):
        x *= (n - i)
        y *= (i + 1)
        x %= mod
        y %= mod
    return (x * modinv(y, mod)) % mod

ans = pow(2, n, mod)
ans -= combination(n,a) + combination(n,b) + 1

print((ans % mod))
# Original solution
mod = 10**9 +7
n, a, b = list(map(int, input().split()))

nb = str(bin(n))[2:]
nblis = []
for k in range(len(nb)):
  if nb[-k-1] == '1':
    nblis.append(k)

two = [2]
for k in range(len(nb)-1):
  two.append(two[-1]*two[-1]%mod)


ans = 1
for item in nblis:
  ans = ans * two[item] %mod



bi = str(bin(mod-2))[2:]
blis = []
for k in range(len(bi)):
  if bi[-k-1] == '1':
    blis.append(k)


def modinv(N):
  if N == 1:
    return 1
  else:
    res = 1
    li = []
    for _ in range(len(bi)):
      li.append(N%mod)
      N = N*N%mod
    for item in blis:
      res = res * li[item] %mod
    return res

ans_a = 1
for k in range(n-a+1, n+1):
  ans_a = ans_a*k%mod
for k in range(2, a+1):
  ans_a = ans_a*modinv(k)%mod


ans_b = 1
for k in range(n-b+1, n+1):
  ans_b = ans_b*k%mod
for k in range(2, b+1):
  ans_b = ans_b*modinv(k)%mod

print(((ans-ans_a-ans_b-1)%mod))

# Optimized solution
mod = 10**9 +7
n, a, b = list(map(int, input().split()))

nb = str(bin(n))[2:]
nblis = []
for k in range(len(nb)):
  if nb[-k-1] == '1':
    nblis.append(k)

two = [2]
for k in range(len(nb)-1):
  two.append(two[-1]*two[-1]%mod)


ans = 1
for item in nblis:
  ans = ans * two[item] %mod



bi = str(bin(mod-2))[2:]
blis = []
for k in range(len(bi)):
  if bi[-k-1] == '1':
    blis.append(k)


def modinv(N):
  if N == 1:
    return 1
  else:
    res = 1
    li = []
    for _ in range(len(bi)):
      li.append(N%mod)
      N = N*N%mod
    for item in blis:
      res = res * li[item] %mod
    return res

ans_a = 1
for k in range(n-a+1, n+1):
  ans_a = ans_a*k%mod
amother = 1
for k in range(2, a+1):
  amother = amother * k % mod
ans_a = ans_a*modinv(amother)%mod


ans_b = 1
for k in range(n-b+1, n+1):
  ans_b = ans_b*k%mod
bmother = 1
for k in range(2, b+1):
  bmother = bmother * k % mod  
ans_b = ans_b*modinv(bmother)%mod

print(((ans-ans_a-ans_b-1)%mod))
# Original solution
MOD = 10**9 + 7
n, a, b = list(map(int, input().split()))

def comb(n, k):
    x, y = 1, 1
    for i in range(n, n-k, -1):
        x = x * i % MOD
    for i in range(2, k+1):
        y = y * pow(i, MOD-2, MOD) % MOD
    return x*y % MOD

ans = (pow(2, n, MOD)-1-comb(n,a)-comb(n,b)) % MOD

print(ans)

# Optimized solution
from functools import reduce
MOD = 10**9 + 7
n, a, b = list(map(int, input().split()))

def comb(n, k):
    def mul(a, b):
        return a*b%MOD
    x = reduce(mul, list(range(n, n-k, -1)))
    y = reduce(mul, list(range(1, k+1)))
    return x*pow(y, MOD-2, MOD) % MOD

ans = (pow(2, n, MOD)-1-comb(n,a)-comb(n,b)) % MOD

print(ans)
# Original solution
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def MI(): return map(int, input().split())


def S(): return input()


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
# sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']


# show_flg = True
show_flg = False


def f(n):
    r = (n - 2)
    m = (4 * (1 - pow(2, r, MOD))) // (1 - 2)
    return (3 + m) % MOD


def modinv(a):
    return pow(a, MOD-2, MOD)


def cmb(n, r):
    p = 1
    c = 1
    for i in range(r):
        p *= (n - i)
        c *= (i + 1)
        p = p % MOD
        c = c % MOD
    return p * modinv(c) % MOD


def main():
    n, a, b = MI()
    first = cmb(n, a)
    second = cmb(n, b)
    ans = f(n)
    print((ans - first - second) % MOD)


if __name__ == '__main__':
    main()


# Optimized solution
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate
import sys
import bisect
import string
import math
import time


def I(): return int(input())


def MI(): return map(int, input().split())


def S(): return input()


def MS(): return map(str, input().split())


def LI(): return [int(i) for i in input().split()]


def LI_(): return [int(i)-1 for i in input().split()]


def StoI(): return [ord(i)-97 for i in input()]


def ItoS(nn): return chr(nn+97)


def input(): return sys.stdin.readline().rstrip()


def show(*inp, end='\n'):
    if show_flg:
        print(*inp, end=end)


YNL = {False: 'No', True: 'Yes'}
YNU = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**10
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
# sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']


# show_flg = True
show_flg = False


def modinv(a):
    return pow(a, MOD-2, MOD)


def cmb(n, r):
    p = 1
    c = 1
    for i in range(r):
        p *= (n - i)
        c *= (i + 1)
        p = p % MOD
        c = c % MOD
    return p * modinv(c) % MOD


def main():
    n, a, b = MI()
    first = cmb(n, a)
    second = cmb(n, b)
    ans = pow(2, n, MOD) - 1
    print((ans - first - second) % MOD)


if __name__ == '__main__':
    main()
# Original solution
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

mod = 10**9+7

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

def comb(n, k):
    c = 1
    for i in range(n - k + 1, n + 1):
        c *= i
        c %= mod

    for i in range(1, k + 1):
        c *= pow(i, mod - 2, mod)
        c %= mod

    return c

ans = pow(2, n, mod) - 1 - comb(n, a) - comb(n, b)
print((ans % mod))


# Optimized solution
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline

mod = 10**9+7

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

# def comb(n, k):
#     c = 1
#     for i in range(n - k + 1, n + 1):
#         c *= i
#         c %= mod
#
#     for i in range(1, k + 1):
#         c *= pow(i, mod - 2, mod)
#         c %= mod
#
#     return c

def comb(n, k):
    c = 1
    for i in range(k):
        c *= n - i
        c %= mod

    d = 1
    for i in range(1, k + 1):
        d *= i
        d %= mod

    return (c * pow(d, mod - 2, mod)) % mod

ans = pow(2, n, mod) - 1 - comb(n, a) - comb(n, b)
print((ans % mod))
# Original solution
n,a,b=list(map(int,input().split()))
m=10**9+7
def c(x,r=1):
 for i in range(x):r=r*(n-i)*pow(i+1,m-2,m)%m
 return r
print(((pow(2,n,m)-1-c(a)-c(b))%m))

# Optimized solution
n,a,b=list(map(int,input().split()))
m=10**9+7
s=r=1
for i in range(b):
 r=r*(n-i)*pow(i+1,m-2,m)%m
 if i+1in[a,b]:s+=r
print(((pow(2,n,m)-s)%m))
# Original solution
def get_exp_mod(base, exp, mod):
    exp_bin = str(format(exp, 'b'))  # ２進表現
    res = 1
    for i in range(len(exp_bin)):
        if exp_bin[-i - 1] == '1':
            res = res * base % mod
        base = base * base % mod  # base^2^nをmodで割ったあまり

    return res


mod = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))

## TODO:0の時

# 2^n -1のmodを求める
all_case = (get_exp_mod(2, n, mod) - 1) % mod
#print(all_case)

# nCa modを求める
case_a = 1
for i in range(a):
    case_a = case_a * (n - i) % mod
    case_a = case_a * get_exp_mod(i+1, mod-2, mod) % mod
#print(case_a)

case_b = 1
for i in range(b):
    case_b = case_b * (n - i) % mod
    case_b = case_b * get_exp_mod(i+1, mod-2, mod) % mod
#print(case_b)

print(((all_case - case_a - case_b) % mod))


# Optimized solution
def get_exp_mod(base, exp, mod):
    exp_bin = str(format(exp, 'b'))  # ２進表現
    res = 1
    for i in range(len(exp_bin)):
        if exp_bin[-i - 1] == '1':
            res = res * base % mod
        base = base * base % mod  # base^2^nをmodで割ったあまり

    return res


def comb(n, r, mod):
    X = 1
    Y = 1
    for i in range(r):
        X = X * (n - i) % mod
        Y = Y * (i + 1) % mod
    return X * get_exp_mod(Y, mod - 2, mod) % mod


mod = 10 ** 9 + 7
n, a, b = list(map(int, input().split()))


# 2^n -1のmodを求める
all_case = (get_exp_mod(2, n, mod) - 1) % mod

# nCa modを引く
print(((all_case - comb(n, a, mod) - comb(n, b, mod)) % mod))
# Original solution
from functools import reduce

def comb(n, k, p):
  a = reduce(lambda x,y: x*y%p, list(range(n,n-k,-1)))
  b = reduce(lambda x,y: x*y%p, list(range(1,k+1)))
  return (a*pow(b, p-2, p))%p
      
n, a, b = list(map(int, input().split()))
MOD = 10**9 + 7
     
print(((pow(2,n,MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD))%MOD))

# Optimized solution
from functools import reduce
  
def perm(n, k, p):
  ret = 1
  for i in range(n, n-k, -1):
    ret = (ret * i)%p
  return ret

def comb(n, k, p):
  """power_funcを用いて(nCk) mod p を求める"""
  a = perm(n, k, p)
  b = perm(k, k, p)
  return (a*pow(b, p-2, p))%p
  
n, a, b = list(map(int, input().split()))

MOD = 10**9 + 7


print(((pow(2,n,MOD) - 1 - comb(n, a, MOD) - comb(n, b, MOD))%MOD))
# Original solution
n,a,b=list(map(int,input().split()))
mod=pow(10,9)+7

def pow_speed(x,n,mod):
    res = 1
    while n > 0:
        if n & 1 == 1:
            res *= x
        x *= x
        x%=mod
        n >>= 1
    return res

def comb(n,x):
    rec=1
    for i in range(n-x+1,n+1):
        rec=rec*i%mod
    rec2=1
    for i in range(1,x+1):
        rec2=rec2*i%mod
    rec2=pow_speed(rec2,mod-2,mod)
    return rec*rec2

print(((pow_speed(2,n,mod)-comb(n,a)-comb(n,b)-1)%mod))

# Optimized solution
n,a,b=list(map(int,input().split()))
mod=10**9+7

#modあり
def pow_speed(x,n):
    res = 1
    while n > 0:
        if n & 1 == 1:
            res *= x
        x *= x
        x%=mod
        n >>= 1
    return res

#nCx(mod)
def comb_speed(n,x):
    rec=1
    for i in range(n-x+1,n+1):
        rec=rec*i%mod
    rec2=1
    for i in range(1,x+1):
        rec2=rec2*i%mod
    rec2=pow_speed(rec2,mod-2)
    return (rec*rec2)%mod

print(((pow_speed(2,n)-comb_speed(n,a)-comb_speed(n,b)-1)%mod))
# Original solution
n,a,b = list(map(int,input().split()))
mod = 10**9+7
ans = pow(2,n,mod)-1

comb1 = 1
for i in range(n-a+1, n+1):
    comb1 *= i
    comb1 %=  mod
for i in range(1, a+1):
    comb1 *= pow(i, mod-2, mod)
    comb1 %=  mod

comb2 = 1
for i in range(n-b+1, n+1):
    comb2 *= i
    comb2 %=  mod
for i in range(1, b+1):
    comb2 *= pow(i, mod-2, mod)
    comb2 %=  mod
ans -= (comb1 + comb2)
print((ans % mod))

# Optimized solution
def comb(n,k):
    nCk = 1
    mod = 10**9+7
    for i in range(n-k+1, n+1):
        nCk *= i
        nCk %= mod
    for i in range(1, k+1):
        nCk *= pow(i, mod-2, mod)
        nCk %= mod
    return nCk

n,a,b = list(map(int,input().split()))
mod = 10**9+7
print(((pow(2,n,mod) - 1 - comb(n,a) - comb(n,b))%mod))
# Original solution
n,a,b = list(map(int,input().split()))
mod = 10**9+7
a = min(a,n-a)
b = min(b,n-b)
m = max(a,b)
X = [0]*(m+1)
Y = [0]*(m+1)
X[0] = 1
X[1] = n
Y[0] = Y[1] = 1

for i in range(2,m+1):
    X[i] = X[i-1]*(n-i+1)%mod
    Y[i] = Y[i-1]*i%mod
    
ans = (((pow(2,n,mod)-1)%mod-X[a]*pow(Y[a],mod-2,mod)%mod)%mod-X[b]*pow(Y[b],mod-2,mod)%mod)%mod
print(ans)

# Optimized solution
n,a,b = list(map(int,input().split()))
mod = 10**9+7
def combmod(n,k,mod):
    x = y = 1
    for i in range(min(k,n-k)):
        x = x*(n-i)%mod
        y = y*(i+1)%mod
    return x * pow(y, mod-2, mod) % mod
ans = (((pow(2, n, mod) - 1)%mod - combmod(n, a, mod))%mod - combmod(n, b, mod))%mod
print(ans)