// Arup Guha
// 11/3/2013
// Solution to 2013 South East Regional Problem E: Skyscrapers

// Note: This solution requires quite a bit of heap space. I double checked
//       with the chief judge and in this contest, the amount of space I use
//       in this solution was allowed in the contest (two arrays of longs of
//       size 25,000,000.) One work around is to store these two arrays as
//       ints. Since intermediate calculations may be longs, you do the 
//       calculation as a long and then store the final result (which is always
//       an int) back into the int array. This cuts storage by half.

import java.util.*;

public class skyscrapers {

	final public static long MOD = 1000000007;
	public static long[][] memo;
	public static long[][] combo;
	public static long[] fact;

	public static void main(String[] args) {

		// Set up memo table.
		memo = new long[5001][5001];
		for (int i=0; i<5001; i++)
			Arrays.fill(memo[i], -1);

		combo = new long[5001][5001];
		for (int i=0; i<5001; i++) {
			combo[i][i] = 1;
			combo[i][0] = 1;
		}

		// Build Combo Table.
		for (int i=1; i<5001; i++)
			for (int j=1; j<i; j++)
				combo[i][j] = (combo[i-1][j-1]+combo[i-1][j])%MOD;

		// Build Factorial Table.
		fact = new long[5001];
		fact[0] = 1;
		for (int i=1; i<5001; i++)
			fact[i] = (fact[i-1]*i)%MOD;

		// Read first case.
		Scanner stdin = new Scanner(System.in);
		int n = stdin.nextInt();
		int left = stdin.nextInt();
		int right = stdin.nextInt();

		// Go through each case.
		while (n != 0) {

			// Output result.
			System.out.println(solve(n, left, right));

			// Get next case.
			n = stdin.nextInt();
			left = stdin.nextInt();
			right = stdin.nextInt();
		}
	}

	// Solves given problem.
	public static long solve(int n, int left, int right) {

		// Iterate through trying each location for the tallest building and then solving
		// the subproblem on both sides.
		long ans = 0;
		for (int i=0; i<n; i++) {
			if (i < left-1) continue;
			if (n-i-1 < right-1) continue;
			ans = (ans + (see(i,left-1)*combo[n-1][i]%MOD)*see(n-i-1,right-1))%MOD;
		}
		return ans;
	}

	// Returns the number of ways in a row of n buildings we see exactly k.
	public static long see(int n, int k) {

		// Base cases!
		if (n == 1 && k == 1) return 1;
		if (n == 0 && k == 0) return 1;
		if (k < 1) return 0;
		if (k > n) return 0;
		if (memo[n][k] != -1) return memo[n][k];

		// We derive this formula as follows. If we want the number of arrangements of n buildings
		// build them from the arrangements of n-1 buildings with k observable buildings from one side.
		// Now, we can insert the new smallest building in n-1 slots and still see k buildings. OR, we
		// can insert the smallest building first in an arrangement of n-1 buildings where k-1 are visible.
		memo[n][k] = (((long)(n-1)*see(n-1, k))%MOD + see(n-1,k-1))%MOD;

		// Store and return!
		return memo[n][k];
	}
}