class Modulo_Error(Exception):
    pass

class Modulo():
    def __init__(self,a,n):
        self.a=a%n
        self.n=n

    def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
    def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

    def __neq__(self,other):
        return not(self==other)
    
    #加法
    def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

    def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
    def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
    def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
    def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
    def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#-------------------------------------------------------------------------
M=10**9+7
n,a,b=map(int,input().split())
C=[Modulo(1,M)]*(b+1)

for k in range(1,b+1):
    C[k]=C[k-1]*Modulo(n-(k-1),M)/Modulo(k,M)

print((Modulo(2,M)**n-(C[a]+C[b])-1).a) class Modulo_Error(Exception):
    pass Modulo_Error Exception class Modulo():
    def __init__(self,a,n):
        self.a=a%n
        self.n=n

    def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
    def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

    def __neq__(self,other):
        return not(self==other)
    
    #加法
    def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

    def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
    def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
    def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
    def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
    def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#------------------------------------------------------------------------- Modulo def __init__(self,a,n):
        self.a=a%n
        self.n=n

     __init__ self.a=a%n self.a self a a%n a n self.n=n self.n self n n self self a a n n def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
     __str__ return "{} (mod {})".format(self.a,self.n) "{} (mod {})".format(self.a,self.n) "{} (mod {})".format "{} (mod {})" format self.a self a self.n self n self self def __pos__(self):
        return self

     __pos__ return self self self self def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
     __neg__ return  Modulo(-self.a,self.n) Modulo(-self.a,self.n) Modulo -self.a self.a self a self.n self n self self def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

     __eq__ if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

     isinstance(other,Modulo) isinstance other Modulo return (self.a==other.a) and (self.n==other.n) (self.a==other.a) and (self.n==other.n) self.a==other.a self.a self a other.a other a self.n==other.n self.n self n other.n other n elif isinstance(other,int):
            return (self-other).a==0

     isinstance(other,int) isinstance other int return (self-other).a==0 (self-other).a==0 (self-other).a self-other self other a 0 self self other other def __neq__(self,other):
        return not(self==other)
    
    #加法
     __neq__ return not(self==other) not(self==other) self==other self other self self other other def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

     __add__ if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

     isinstance(other,Modulo) isinstance other Modulo if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
             self.n!=other.n self.n self n other.n other n raise Modulo_Error("異なる法同士の演算です.") Modulo_Error("異なる法同士の演算です.") Modulo_Error "異なる法同士の演算です." return Modulo(self.a+other.a,self.n) Modulo(self.a+other.a,self.n) Modulo self.a+other.a self.a self a other.a other a self.n self n elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

     isinstance(other,int) isinstance other int return Modulo(self.a+other,self.n) Modulo(self.a+other,self.n) Modulo self.a+other self.a self a other self.n self n self self other other def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
     __radd__ if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
     isinstance(other,int) isinstance other int return Modulo(self.a+other,self.n) Modulo(self.a+other,self.n) Modulo self.a+other self.a self a other self.n self n self self other other def __sub__(self,other):
        return self+(-other)

     __sub__ return self+(-other) self+(-other) self -other other self self other other def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
     __rsub__ if isinstance(other,int):
            return -self+other
        
    #乗法
     isinstance(other,int) isinstance other int return -self+other -self+other -self self other self self other other def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
     __mul__ if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
     isinstance(other,Modulo) isinstance other Modulo if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
             self.n!=other.n self.n self n other.n other n raise Modulo_Error("異なる法同士の演算です.") Modulo_Error("異なる法同士の演算です.") Modulo_Error "異なる法同士の演算です." return Modulo(self.a*other.a,self.n) Modulo(self.a*other.a,self.n) Modulo self.a*other.a self.a self a other.a other a self.n self n elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
     isinstance(other,int) isinstance other int return Modulo(self.a*other,self.n) Modulo(self.a*other,self.n) Modulo self.a*other self.a self a other self.n self n self self other other def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
     __rmul__ if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
     isinstance(other,int) isinstance other int return Modulo(self.a*other,self.n) Modulo(self.a*other,self.n) Modulo self.a*other self.a self a other self.n self n self self other other def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
     Modulo_Inverse x0, y0, x1, y1 = 1, 0, 0, 1 x0 1 y0 0 x1 0 y1 1 a,b=self.a,self.n a self.a self a b self.n self n while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

         b != 0 b 0 q, a, b = a // b, b, a % b q a // b a b a b b a % b a b x0, x1 = x1, x0 - q * x1 x0 x1 x1 x0 - q * x1 x0 q * x1 q x1 y0, y1 = y1, y0 - q * y1 y0 y1 y1 y0 - q * y1 y0 q * y1 q y1 if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
     a!=1 a 1 raise Modulo_Error("{}の逆数が存在しません".format(self)) Modulo_Error("{}の逆数が存在しません".format(self)) Modulo_Error "{}の逆数が存在しません".format(self) "{}の逆数が存在しません".format "{}の逆数が存在しません" format self return Modulo(x0,self.n) Modulo(x0,self.n) Modulo x0 self.n self n self self def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
     __truediv__ return self*other.Modulo_Inverse() self*other.Modulo_Inverse() self other.Modulo_Inverse() other.Modulo_Inverse other Modulo_Inverse self self other other def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#------------------------------------------------------------------------- __pow__ u=abs(m) u abs(m) abs m r=Modulo(1,self.n) r Modulo(1,self.n) Modulo 1 self.n self n while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

         u>0 u 0 if u%2==1:
                r*=self
             u%2==1 u%2 u 2 1 r*=self r self self*=self self self u=u>>1 u u>>1 u 1 if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#------------------------------------------------------------------------- m>=0 m 0 return r r return r.Modulo_Inverse() r.Modulo_Inverse() r.Modulo_Inverse r Modulo_Inverse self self m m M=10**9+7 M 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 C=[Modulo(1,M)]*(b+1) C [Modulo(1,M)]*(b+1) [Modulo(1,M)] Modulo(1,M) Modulo 1 M b+1 b 1 for k in range(1,b+1):
    C[k]=C[k-1]*Modulo(n-(k-1),M)/Modulo(k,M) k range(1,b+1) range 1 b+1 b 1 C[k]=C[k-1]*Modulo(n-(k-1),M)/Modulo(k,M) C[k] C k C[k-1]*Modulo(n-(k-1),M)/Modulo(k,M) C[k-1]*Modulo(n-(k-1),M) C[k-1] C k-1 k 1 Modulo(n-(k-1),M) Modulo n-(k-1) n k-1 k 1 M Modulo(k,M) Modulo k M print((Modulo(2,M)**n-(C[a]+C[b])-1).a) print (Modulo(2,M)**n-(C[a]+C[b])-1).a Modulo(2,M)**n-(C[a]+C[b])-1 Modulo(2,M)**n-(C[a]+C[b]) Modulo(2,M)**n Modulo(2,M) Modulo 2 M n C[a]+C[b] C[a] C a C[b] C b 1 a n,a,b=map(int,input().split()) map(int,input().split()) n class Modulo_Error(Exception):
    pass class Modulo_Error(Exception):
    pass Modulo_Error C=[Modulo(1,M)]*(b+1) [Modulo(1,M)]*(b+1) C b=map(int,input().split()) map(int,input().split()) b class Modulo():
    def __init__(self,a,n):
        self.a=a%n
        self.n=n

    def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
    def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

    def __neq__(self,other):
        return not(self==other)
    
    #加法
    def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

    def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
    def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
    def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
    def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
    def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#------------------------------------------------------------------------- class Modulo():
    def __init__(self,a,n):
        self.a=a%n
        self.n=n

    def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
    def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

    def __neq__(self,other):
        return not(self==other)
    
    #加法
    def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

    def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
    def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
    def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
    def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
    def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#------------------------------------------------------------------------- Modulo a,b=map(int,input().split()) map(int,input().split()) a M=10**9+7 10**9+7 M
class Modulo_Error(Exception):
    pass

class Modulo():
    def __init__(self,a,n):
        self.a=a%n
        self.n=n

    def __str__(self):
        return "{} (mod {})".format(self.a,self.n)

    #+,-
    def __pos__(self):
        return self

    def __neg__(self):
        return  Modulo(-self.a,self.n)

    #等号,不等号
    def __eq__(self,other):
        if isinstance(other,Modulo):
            return (self.a==other.a) and (self.n==other.n)
        elif isinstance(other,int):
            return (self-other).a==0

    def __neq__(self,other):
        return not(self==other)
    
    #加法
    def __add__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a+other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a+other,self.n)

    def __radd__(self,other):
        if isinstance(other,int):
            return Modulo(self.a+other,self.n)
        
    #減法
    def __sub__(self,other):
        return self+(-other)

    def __rsub__(self,other):
        if isinstance(other,int):
            return -self+other
        
    #乗法
    def __mul__(self,other):
        if isinstance(other,Modulo):
            if self.n!=other.n:
                raise Modulo_Error("異なる法同士の演算です.")
            return Modulo(self.a*other.a,self.n)
        elif isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    def __rmul__(self,other):
        if isinstance(other,int):
            return Modulo(self.a*other,self.n)
        
    #Modulo逆数
    def Modulo_Inverse(self):
        x0, y0, x1, y1 = 1, 0, 0, 1
        a,b=self.a,self.n
        while b != 0:
            q, a, b = a // b, b, a % b
            x0, x1 = x1, x0 - q * x1
            y0, y1 = y1, y0 - q * y1

        if a!=1:
            raise Modulo_Error("{}の逆数が存在しません".format(self))
        else:
            return Modulo(x0,self.n)
        
    #除法
    def __truediv__(self,other):
        return self*other.Modulo_Inverse()

    #累乗
    def __pow__(self,m):
        u=abs(m)

        r=Modulo(1,self.n)

        while u>0:
            if u%2==1:
                r*=self
            self*=self
            u=u>>1

        if m>=0:
            return r
        else:
            return r.Modulo_Inverse()

#-------------------------------------------------------------------------
M=10**9+7
n,a,b=map(int,input().split())
C=[Modulo(1,M)]*(b+1)

for k in range(1,b+1):
    C[k]=C[k-1]*Modulo(n-(k-1),M)/Modulo(k,M)

print((Modulo(2,M)**n-(C[a]+C[b])-1).a)
