#include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstring>

#ifdef GONGKUNPENG
#include <cassert>
#endif

#define GG 0
#define GIO 1
#define uint unsigned
#define max(a, b) std::max(a, b)
#define min(a, b) std::min(a, b)
#define swap(a, b) std::swap(a, b)
#define sort(...) std::sort(__VA_ARGS__)
#define ms(a, v) memset(a, v, sizeof(a))
#define sfor(i, n) for (int i = 1; i <= n; ++i)
#define tfor(i, n) for (int i = 0; i < n; ++i)

#if __cplusplus >= 201103L
using ll = long long;
using ull = unsigned long long;
#else
typedef long long ll;
typedef unsigned long long ull;
#endif

#if GIO
struct _gio {
#define BFSZ 1 << 18
#define blank(x) (x == ' ' || x == '\t' || x == '\n' || x == '\r')

#if GG
#else
  char ruf[BFSZ], wuf[BFSZ], *p, *q, *r, rcha;
  bool rneg;
  _gio() : p(ruf), q(ruf), r(wuf), rcha(' ') {}

  ~_gio() { fwrite(wuf, 1, r - wuf, stdout); }
#endif
  inline void flush() { fwrite(wuf, 1, r - wuf, stdout), r = wuf; }

  inline int readc() {
#if GG
    return getchar();
#else
    return (p == q && (q = (p = ruf) + fread(ruf, 1, BFSZ, stdin), p == q)
                ? -1
                : *p++);
#endif
  }

  template <typename T, typename... Args> void read(T &x, Args &... args) {
    read(x), read(args...);
  }

  inline void read() {}

  inline void read(char *s) {
    while (blank(rcha))
      rcha = readc();
    while (!blank(rcha) && rcha > 0)
      *s++ = rcha, rcha = readc();
    *s = '\0';
  }

  inline void readl(char *s) {
    while (blank(rcha))
      rcha = readc();
    while (rcha != '\n' && rcha > 0)
      *s++ = rcha, rcha = readc();
    *s = '\0';
  }

  template <typename T> inline void read(T &x) {
    x = rcha = rneg = 0;
    while (!isdigit(rcha) && rcha != '-')
      rcha = readc();
    rcha == '-' && (rneg = true, rcha = readc());
    while (isdigit(rcha))
      x = (x << 3) + (x << 1) - 48 + rcha, rcha = readc();
    rneg && (x = -x);
  }

  inline void writec(const char &c) {
#if GG
    putchar(c);
#else
    (r - wuf == BFSZ) && (fwrite(wuf, 1, BFSZ, stdout), r = wuf);
    *r++ = c;
#endif
  }

  template <typename T, typename... Args>
  void write(const T &x, const Args &... args) {
    write(x), write(args...);
  }

  template <typename T, typename... Args>
  void writel(const T &x, const Args &... args) {
    write(x), write(args...);
    writec('\n');
  }

  inline void write() {}

  inline void write(const char &c) { writec(c); }

  template <typename T> void write(T x) {
    if (x < 0) {
      writec('-');
      write(-ll(x));
      return;
    }
    if (x > 9)
      write(x / 10);
    writec(x % 10 ^ 48);
  }

  inline void write(const char *s) {
    while (*s)
      writec(*s++);
  }
#undef BFSZ
} io;
#endif

const ll MO = 1000000007;
const ll INF = 0x3f3f3f3f;
const uint MAXN =
#ifdef GONGKUNPENG
    15
#else
    1000000005
#endif
    ;

struct mint {
#define _DEFINED_MINT
#define mod MO
#define _Ty mint
#define _Rf _Ty &
#define _Cf const _Rf
  ll x;
  mint(ll x = 0) : x((x % mod + mod) % mod) {}
  _Ty operator-() const { return _Ty(-x); }
  _Rf operator+=(_Cf a) {
    ((x += a.x) >= mod) && (x -= mod);
    return *this;
  }
  _Rf operator-=(_Cf a) {
    ((x += mod - a.x) >= mod) && (x -= mod);
    return *this;
  }
  _Rf operator*=(_Cf a) {
    x = x * a.x % mod;
    return *this;
  }
  inline _Ty pow(ll p) const {
    _Ty r = 1;
    ll t = x;
    while (p) {
      (p & 1) && (r.x = (r.x * t + mod) % mod);
      p >>= 1, t = (t * t + mod) % mod;
    }
    return r;
  }
  inline _Ty inv() const { return pow(mod - 2); }
  _Rf operator/=(_Cf a) { return (*this) *= a.inv(); }
  _Ty operator+(_Cf a) const {
    _Ty r(*this);
    return r += a;
  }
  _Ty operator-(_Cf a) const {
    _Ty r(*this);
    return r -= a;
  }

  _Ty operator*(_Cf a) const {
    _Ty r(*this);
    return r *= a;
  }

  _Ty operator/(_Cf a) const {
    _Ty r(*this);
    return r /= a;
  }
#undef _Cf
#undef _Rf
#undef _Ty
#undef mod
};

mint c(ll n, ll k) {
  mint ret(1);
  for (ll i = n, e = n - k; i > e; --i)
    ret *= i;
  for (ll i = 1; i <= k; ++i)
    ret /= i;
  return ret;
}

int main() {
  ll a, b, n, r;
  io.read(n, a, b);
  mint ma(a), mb(b), mn(2);
  mn = mn.pow(n);
  mn = mn - 1 - c(n, a) - c(n, b);
  io.write(mn.x, '\n');
  return 0;
}

Measured memory_bytes: 256