// Arup Guha
// 2/3/2018
// Solution to 2017 MCPC Problem H: Hopscotch

import java.util.*;

public class hopscotch {

	public static long MOD = 1000000007L;

	public static long[] fact;
	public static long[] invfact;

	public static void main(String[] args) {

		Scanner stdin = new Scanner(System.in);
		long n = stdin.nextLong();
		long x = stdin.nextLong();
		long y = stdin.nextLong();

		// Store the factorials and their inverses mod MOD.
		fact = new long[((int)n)+1];
		invfact = new long[fact.length];
		invfact[0] = 1;
		fact[0] = 1;
		for (int i=1; i<=n; i++) {
			fact[i] = (fact[i-1]*i)%MOD;
			invfact[i] = modInv(fact[i], MOD);
		}

		ArrayDeque<Long> xList = getList(n, x);
		ArrayDeque<Long> yList = getList(n, y);

		long res = 0;
		
		// Now, we have to match # of solutions in x by # of hops with y, kind of like a dot product...
		while (xList.size() > 0 && yList.size() > 0) {
			
			// Just grab pairs and multiply...
			long xT = xList.pollFirst();
			long yT = yList.pollFirst();
			res = (res + xT*yT)%MOD;
		}

		// Ta da!
		System.out.println(res);
	}

	// Returns a sequence of combinations that represent the solution in one dimension for n and x, where n is the 
	// total distance and x is the minimum hop.
	public static ArrayDeque<Long> getList(long n, long x) {

		ArrayDeque<Long> res = new ArrayDeque<Long>();
		
		// Intial solution is based on # of solutions to x1 = n, where x1 >= x.
		long top = n-x;
		long bot = 0;

		// In general, for each iteration, we add an x, so first time through here, it finds the number
		// of solutions to x1 + x2 = x where x1, x2 >= x. This uses the combinations with repetition formula.
		// As an example, when we have x1 + x2 + x3 = n, we sub out 3x from n to get x1' + x2' + x3' = n - 3x
		// and now for x1', x2', x3' they must be non-neg. This has n - 3x + 2 choose 2 solutions. 2 comes from
		// the number of variables minus 1. So basically we are just iterating the number of hops and adding 
		// each solution to the list.
		while (top >= bot) {
			res.add(choose(top, bot));
			top -= (x-1);
			bot++;
		}

		return res;
	}

	// Fast Modular Exponentiation.
	public static long modExp(long b, long e, long mod) {
		if (e == 0) return 1L;
		if (e%2 == 0) {
			long tmp = modExp(b, e/2, mod);
			return (tmp*tmp)%mod;
		}
		return (b*modExp(b,e-1,mod))%mod;
	}

	// Returns n choose d mod MOD via factorial formula for combos.
	public static long choose(long n, long d) {
		long res = fact[(int)n];
		res = (res*invfact[(int)d])%MOD;
		res = (res*invfact[(int)(n-d)])%MOD;
		return res;
	}

	// Mod Inverse that works for primes via Fermat's Theorem.
	public static long modInv(long b, long a) {
		return modExp(b, a-2, a);
	}
}