import copy

def fast_pow(x, n, MOD):
    res = 1
    while n:
        if n & 1:
            res = res * x % MOD
        x = x * x % MOD
        n >>= 1
    return res
  
  
def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs

MOD = 10**9+7
fact, fact_inv = prepare(2*10**5, MOD)

n, a, b = map(int,input().split())
f = copy.deepcopy(n)
for i in range(1, b+1):
    if i == a:
        nca = f * fact_inv[a] % MOD
    if i == b:
        ncb = f * fact_inv[b] % MOD
        break
    f = f * (n - i) % MOD
print((fast_pow(2, n, MOD) - 1 - nca - ncb) % MOD)
 import copy copy def fast_pow(x, n, MOD):
    res = 1
    while n:
        if n & 1:
            res = res * x % MOD
        x = x * x % MOD
        n >>= 1
    return res
  
   fast_pow res = 1 res 1 while n:
        if n & 1:
            res = res * x % MOD
        x = x * x % MOD
        n >>= 1
     n if n & 1:
            res = res * x % MOD
         n & 1 n 1 res = res * x % MOD res res * x % MOD res * x res x MOD x = x * x % MOD x x * x % MOD x * x x x MOD n >>= 1 n 1 return res res x x n n MOD MOD def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs prepare f = 1 f 1 factorials = [1] factorials [1] 1 for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
     m range(1, n + 1) range 1 n + 1 n 1 f *= m f m f %= MOD f MOD factorials.append(f) factorials.append factorials append f inv = pow(f, MOD - 2, MOD) inv pow(f, MOD - 2, MOD) pow f MOD - 2 MOD 2 MOD invs = [1] * (n + 1) invs [1] * (n + 1) [1] 1 n + 1 n 1 invs[n] = inv invs[n] invs n inv for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
     m range(n, 1, -1) range n 1 -1 inv *= m inv m inv %= MOD inv MOD invs[m - 1] = inv invs[m - 1] invs m - 1 m 1 inv return factorials, invs return factorials, invs factorials invs n n MOD MOD MOD = 10**9+7 MOD 10**9+7 10**9 10 9 7 fact, fact_inv = prepare(2*10**5, MOD) fact prepare(2*10**5, MOD) prepare 2*10**5 2 10**5 10 5 MOD fact_inv n, a, b = map(int,input().split()) n map(int,input().split()) map int input().split() ().split () input split a b f = copy.deepcopy(n) f copy.deepcopy(n) copy.deepcopy copy deepcopy n for i in range(1, b+1):
    if i == a:
        nca = f * fact_inv[a] % MOD
    if i == b:
        ncb = f * fact_inv[b] % MOD
        break
    f = f * (n - i) % MOD i range(1, b+1) range 1 b+1 b 1 if i == a:
        nca = f * fact_inv[a] % MOD
     i == a i a nca = f * fact_inv[a] % MOD nca f * fact_inv[a] % MOD f * fact_inv[a] f fact_inv[a] fact_inv a MOD if i == b:
        ncb = f * fact_inv[b] % MOD
        break
     i == b i b ncb = f * fact_inv[b] % MOD ncb f * fact_inv[b] % MOD f * fact_inv[b] f fact_inv[b] fact_inv b MOD break f = f * (n - i) % MOD f f * (n - i) % MOD f * (n - i) f n - i n i MOD print((fast_pow(2, n, MOD) - 1 - nca - ncb) % MOD) print (fast_pow(2, n, MOD) - 1 - nca - ncb) % MOD fast_pow(2, n, MOD) - 1 - nca - ncb fast_pow(2, n, MOD) - 1 - nca fast_pow(2, n, MOD) - 1 fast_pow(2, n, MOD) fast_pow 2 n MOD 1 nca ncb MOD ncb = f * fact_inv[b] % MOD f * fact_inv[b] % MOD ncb b = map(int,input().split()) map(int,input().split()) b def fast_pow(x, n, MOD):
    res = 1
    while n:
        if n & 1:
            res = res * x % MOD
        x = x * x % MOD
        n >>= 1
    return res
  
   def fast_pow(x, n, MOD):
    res = 1
    while n:
        if n & 1:
            res = res * x % MOD
        x = x * x % MOD
        n >>= 1
    return res
  
   fast_pow f = copy.deepcopy(n) copy.deepcopy(n) f MOD = 10**9+7 10**9+7 MOD fact, fact_inv = prepare(2*10**5, MOD) prepare(2*10**5, MOD) fact a, b = map(int,input().split()) map(int,input().split()) a nca = f * fact_inv[a] % MOD f * fact_inv[a] % MOD nca n, a, b = map(int,input().split()) map(int,input().split()) n f = f * (n - i) % MOD f * (n - i) % MOD f fact_inv = prepare(2*10**5, MOD) prepare(2*10**5, MOD) fact_inv def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs prepare
import copy

def fast_pow(x, n, MOD):
    res = 1
    while n:
        if n & 1:
            res = res * x % MOD
        x = x * x % MOD
        n >>= 1
    return res
  
  
def prepare(n, MOD):
 
    # 1! - n! の計算
    f = 1
    factorials = [1]  # 0!の分
    for m in range(1, n + 1):
        f *= m
        f %= MOD
        factorials.append(f)
    # n!^-1 の計算
    inv = pow(f, MOD - 2, MOD)
    # n!^-1 - 1!^-1 の計算
    invs = [1] * (n + 1)
    invs[n] = inv
    for m in range(n, 1, -1):
        inv *= m
        inv %= MOD
        invs[m - 1] = inv
     
    return factorials, invs

MOD = 10**9+7
fact, fact_inv = prepare(2*10**5, MOD)

n, a, b = map(int,input().split())
f = copy.deepcopy(n)
for i in range(1, b+1):
    if i == a:
        nca = f * fact_inv[a] % MOD
    if i == b:
        ncb = f * fact_inv[b] % MOD
        break
    f = f * (n - i) % MOD
print((fast_pow(2, n, MOD) - 1 - nca - ncb) % MOD)

