import java.io.{BufferedOutputStream, BufferedReader, InputStreamReader, PrintWriter}

import scala.annotation.tailrec

object Main {
  val p = 1000000000 + 7

  @inline
  def submod(a: Long, b: Long): Long = {
    ((a - b) % p + p) % p
  }

  @inline
  def mulmod(a: Long, b: Long): Long = {
    a * b % p
  }

  @inline
  def invmod(a: Long): Long = {
    (extGCD(a, p)._1 + p) % p
  }

  def extGCD(a: Long, b: Long): (Long, Long, Long) = {
    if (b == 0) {
      (1L, 0L, a)
    } else {
      val (y, x, d) = extGCD(b, a % b)
      (x, y - a / b * x, d)
    }
  }

  def powerMod(a: Int, n: Int): Long = {
    @tailrec
    def power(cur: Long, a: Long, n: Int): Long = {
      if (n == 0) {
        cur
      } else {
        power(mulmod(cur, if (n % 2 == 0) 1 else a), mulmod(a, a), n / 2)
      }
    }

    power(1L, a, n)
  }

  def main(args: Array[String]): Unit = {
    val in = new BufferedReader(new InputStreamReader(System.in))
    val out = new PrintWriter(new BufferedOutputStream(System.out))
    val Array(n, a, b) = in.readLine().split("\\s+").map(_.toInt)

    val power2n = powerMod(2, n)
    val a_fact = {
      var f = 1L
      for {
        i <- 2 to a
      } {
        f = mulmod(f, i)
      }
      f
    }
    val b_fact = {
      var f = a_fact
      for {
        i <- (a + 1) to b
      } {
        f = mulmod(f, i)
      }
      f
    }
    val na_fact = {
      var f = 1L
      for {
        i <- n to (n - a + 1) by -1
      } {
        f = mulmod(f, i)
      }
      f
    }
    val nb_fact = {
      var f = na_fact
      for {
        i <- (n - a) to (n - b + 1) by -1
      } {
        f = mulmod(f, i)
      }
      f
    }
    val b_fact_inv = invmod(b_fact)
    val a_fact_inv = invmod(a_fact)

    out.println(
      submod(
        submod(
          submod(power2n, 1),
          mulmod(
            na_fact,
            a_fact_inv
          )
        ),
        mulmod(
          nb_fact,
          b_fact_inv
        )
      )
    )

    out.flush()
  }
}
