import std.stdio, std.conv, std.array, std.string, std.algorithm, std.container, std.range, core.stdc.stdlib, std.math, std.typecons;
T[][] combinations(T)(T[] s, in int m) {   if (!m) return [[]];   if (s.empty) return [];   return s[1 .. $].combinations(m - 1).map!(x => s[0] ~ x).array ~ s[1 .. $].combinations(m); }
import std.bigint, std.functional;

const MOD = 1000000000 + 7;

class FermetCalculator {
	ulong[] factrial; //階乗を保持
	ulong[] inverse;  //逆元を保持
	
	this(ulong size) {
		factrial = new ulong[size + 1];
		inverse = new ulong[size + 1];
		factrial[0] = 1;
		inverse[0] = 1;
		
		for (ulong i = 1; i <= size; i++) {
			factrial[i] = (factrial[i - 1] * i) % MOD;  //階乗を求める
			inverse[i] = pow(factrial[i], MOD - 2) % MOD; // フェルマーの小定理で逆元を求める
		}
	}
	
	ulong combine(ulong n, ulong k) {
		return factrial[n] * inverse[k] % MOD * inverse[n - k] % MOD;
	}
	
	ulong pow(ulong x, ulong n) { //x^n 計算量O(logn)
		ulong ans = 1;
		while (n > 0) {
			if ((n & 1) == 1) {
				ans = ans * x % MOD;
			}
			x = x * x % MOD; //一周する度にx, x^2, x^4, x^8となる
			n >>= 1; //桁をずらす n = n >> 1
		}
		return ans;
	}
}

void main() {
  auto INPUT = readln.split.to!(ulong[]);
  auto N = INPUT[0];
  auto A = INPUT[1];
  auto B = INPUT[2];

  auto fermetCalculator = new FermetCalculator(N);

  ulong solve() {
    ulong answer;
    foreach(i; 1..N+1) {
      if (i == A || i == B) continue;

      answer = (answer + fermetCalculator.combine(N, i)) % MOD;
    }

    return answer;
  }

  solve().writeln;
}
