3 3 1
 300 2 300
 4000 4000 1
 4000 4000 100
 4 2 3
 3 300 300
 4000 100 4000
 3 300 1
 300 300 1
 4000 1000 3000
 3 2 4000
 4 3 2
 3 2 300
 4000 3998 2
 100 200 300
 300 300 300
 3 3 3
 10 10 10
 10 4 9
 239 300 231
 4000 2 3998
 200 100 300
 4000 2000 2000
 4000 4000 4000
 10 7 5
 4000 100 3900
 3 4000 4000

12
 775907030
 63263244
 994443885
 24
 496527918
 908339579
 828107078
 775907030
 876839920
 938379934
 48
 196174631
 296557186
 316471646
 375912430
 72
 318389383
 135283173
 774612666
 686088712
 949581532
 310481606
 997463324
 130636800
 221262673
 680114446

#include <bits/stdc++.h>
using namespace std;
template <int MOD = 1000000009>
struct ModInteger {
  int x;
  ModInteger(int x = 0) : x(x) {}
  int getValue() { return x; }
  void operator=(const int v) { x = v; }
  ModInteger operator+(const int v) {
    return ModInteger(x >= MOD - v ? x - MOD + v : x + v);
  }
  ModInteger operator+(const ModInteger &rhs) {
    return ModInteger(x >= MOD - rhs.x ? x - MOD + rhs.x : x + rhs.x);
  }
  void operator+=(const int v) { x = x >= MOD - v ? x - MOD + v : x + v; }
  void operator+=(const ModInteger &rhs) {
    x = x >= MOD - rhs.x ? x - MOD + rhs.x : x + rhs.x;
  }
  ModInteger operator-(const int v) {
    return ModInteger(x < v ? x - v + MOD : x - v);
  }
  ModInteger operator-(const ModInteger &rhs) {
    return ModInteger(x < rhs.x ? x - rhs.x + MOD : x - rhs.x);
  }
  void operator-=(const int v) { x = x < v ? x - v + MOD : x - v; }
  void operator-=(const ModInteger &rhs) {
    x = x < rhs.x ? x - rhs.x + MOD : x - rhs.x;
  }
  ModInteger operator*(const int v) {
    return ModInteger((long long)x * v % MOD);
  }
  ModInteger operator*(const ModInteger &rhs) {
    return ModInteger((long long)x * rhs.x % MOD);
  }
  void operator*=(const int v) { x = (long long)x * v % MOD; }
  void operator*=(const ModInteger &rhs) { x = (long long)x * rhs.x % MOD; }
  ModInteger operator^(int e) {
    ModInteger res = ModInteger(1), a = *this;
    for (; e; e >>= 1, a *= a)
      if (e & 1) res *= a;
    return res;
  }
  void operator^=(int e) {
    ModInteger res = ModInteger(1), a = *this;
    for (; e; e >>= 1, a *= a)
      if (e & 1) res *= a;
    x = res.x;
  }
  ModInteger operator/(const int v) {
    return ModInteger((long long)x * (ModInteger(v) ^ (MOD - 2)).getValue() %
                      MOD);
  }
  ModInteger operator/(const ModInteger &rhs) {
    ModInteger a = rhs;
    return ModInteger((long long)x * (a ^ (MOD - 2)).getValue() % MOD);
  }
  void operator/=(const int v) {
    x = (long long)x * (ModInteger(v) ^ (MOD - 2)).getValue() % MOD;
  }
  void operator/=(const ModInteger &rhs) {
    ModInteger a = rhs;
    x = (long long)x * (a ^ (MOD - 2)).getValue() % MOD;
  }
};
const int MAXN = 4096;
ModInteger<> fact[MAXN];
int n, w, b;
ModInteger<> calc(int n, int m) {
  if (n > m) return ModInteger<>(0);
  return fact[m - 1] / fact[n - 1] / fact[m - n];
}
int main() {
  fact[0] = ModInteger<>(1);
  for (int i = (1); i < (MAXN); i++) fact[i] = fact[i - 1] * i;
  scanf("%d%d%d", &n, &w, &b);
  ModInteger<> res = ModInteger<>(0);
  for (int i = (2); i < (n); i++) res += calc(i, w) * calc(n - i, b) * (i - 1);
  res *= fact[w] * fact[b];
  printf("%d\n", res.getValue());
  return 0;
}
