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>
#pragma GCC optimize(0)
namespace orz {
inline void read(int &x) { scanf("%d", &x); }
inline void read(unsigned int &x) { scanf("%u", &x); }
inline void read(long long &x) { scanf("%I64d", &x); }
inline void read(unsigned long long &x) { scanf("%I64u", &x); }
inline void read(double &x) { scanf("%lf", &x); }
inline void read(long double &x) {
  double tmp;
  read(tmp);
  x = tmp;
}
inline void read(char &x) { x = getchar(); }
inline void read(char *x) { scanf("%s", x); }
template <class T>
inline void read(T *a, int n) {
  for (int i = (0); i < (n); ++i) read(a[i]);
}
template <class T1, class T2>
inline void read(T1 &a, T2 &b) {
  read(a);
  read(b);
}
template <class T1, class T2, class T3>
inline void read(T1 &a, T2 &b, T3 &c) {
  read(a);
  read(b);
  read(c);
}
template <class T1, class T2, class T3, class T4>
inline void read(T1 &a, T2 &b, T3 &c, T4 &d) {
  read(a);
  read(b);
  read(c);
  read(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void read(T1 &a, T2 &b, T3 &c, T4 &d, T5 &e) {
  read(a);
  read(b);
  read(c);
  read(d);
  read(e);
}
inline void write(int x) { printf("%d", x); }
inline void write(unsigned int x) { printf("%u", x); }
inline void write(long long x) { printf("%I64d", x); }
inline void write(unsigned long long x) { printf("%I64u", x); }
inline void write(double x) { printf("%.10lf", x); }
inline void write(long double x) { printf("%.10lf", (double)x); }
inline void write(char x) { putchar(x); }
inline void write(char *x) { printf("%s", x); }
template <class T>
inline void writes(T x) {
  write(x);
  putchar(' ');
}
template <class T1, class T2>
inline void writes(T1 a, T2 b) {
  writes(a);
  writes(b);
}
template <class T1, class T2, class T3>
inline void writes(T1 a, T2 b, T3 c) {
  writes(a);
  writes(b);
  writes(c);
}
template <class T1, class T2, class T3, class T4>
inline void writes(T1 a, T2 b, T3 c, T4 d) {
  writes(a);
  writes(b);
  writes(c);
  writes(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void writes(T1 a, T2 b, T3 c, T4 d, T5 e) {
  writes(a);
  writes(b);
  writes(c);
  writes(d);
  writes(e);
}
template <class T1, class T2>
inline void writesln(T1 a, T2 b) {
  writes(a);
  writes(b);
  putchar('\n');
}
template <class T1, class T2, class T3>
inline void writesln(T1 a, T2 b, T3 c) {
  writes(a);
  writes(b);
  writes(c);
  putchar('\n');
}
template <class T1, class T2, class T3, class T4>
inline void writesln(T1 a, T2 b, T3 c, T4 d) {
  writes(a);
  writes(b);
  writes(c);
  writes(d);
  putchar('\n');
}
template <class T1, class T2, class T3, class T4, class T5>
inline void writesln(T1 a, T2 b, T3 c, T4 d, T5 e) {
  writes(a);
  writes(b);
  writes(c);
  writes(d);
  writes(e);
  putchar('\n');
}
template <class T1, class T2>
inline void writeln(T1 a, T2 b) {
  write(a);
  write(b);
  putchar('\n');
}
template <class T1, class T2, class T3>
inline void writeln(T1 a, T2 b, T3 c) {
  write(a);
  write(b);
  write(c);
  putchar('\n');
}
template <class T1, class T2, class T3, class T4>
inline void writeln(T1 a, T2 b, T3 c, T4 d) {
  write(a);
  write(b);
  write(c);
  write(d);
  putchar('\n');
}
template <class T1, class T2, class T3, class T4, class T5>
inline void writeln(T1 a, T2 b, T3 c, T4 d, T5 e) {
  write(a);
  write(b);
  write(c);
  write(d);
  write(e);
  putchar('\n');
}
template <class T1, class T2>
inline void write(T1 a, T2 b) {
  write(a);
  write(b);
}
template <class T1, class T2, class T3>
inline void write(T1 a, T2 b, T3 c) {
  write(a);
  write(b);
  write(c);
}
template <class T1, class T2, class T3, class T4>
inline void write(T1 a, T2 b, T3 c, T4 d) {
  write(a);
  write(b);
  write(c);
  write(d);
}
template <class T1, class T2, class T3, class T4, class T5>
inline void write(T1 a, T2 b, T3 c, T4 d, T5 e) {
  write(a);
  write(b);
  write(c);
  write(d);
  write(e);
}
template <class T>
inline void writeln(T x) {
  write(x);
  putchar('\n');
}
template <class T>
inline void writeln(T *a, int n) {
  for (int i = (0); i < (n); ++i) write(a[i]);
  putchar('\n');
}
template <class T>
inline void writesln(T *a, int n) {
  for (int i = (0); i < (n); ++i) writes(a[i]);
  putchar('\n');
}
template <class T>
inline void writelnln(T *a, int n) {
  for (int i = (0); i < (n); ++i) writeln(a[i]);
}
}  // namespace orz
using namespace orz;
const long long MOD = 1000000009LL;
inline long long pow(long long x, long long y) {
  long long ans = 1;
  for (int i = (60); i >= (0); --i) {
    ans = ans * ans % MOD;
    if (y & (1LL << i)) ans = ans * x % MOD;
  }
  return ans;
}
long long fac[4086], invfac[4086];
inline long long C(int x, int y) {
  return fac[x] * invfac[y] % MOD * invfac[x - y] % MOD;
}
int main() {
  int n, w, b;
  read(n, w, b);
  fac[0] = invfac[0] = 1;
  for (int i = (1); i <= (4008); ++i) {
    fac[i] = fac[i - 1] * (long long)i % MOD;
    invfac[i] = invfac[i - 1] * (long long)pow(i, MOD - 2LL) % MOD;
  }
  long long ans = 0;
  for (int i = (2); i < (n); ++i)
    ans = (ans + (long long)(i - 1) * fac[w] % MOD * fac[b] % MOD *
                     C(w - 1, i - 1) % MOD * C(b - 1, n - i - 1) % MOD) %
          MOD;
  writeln(ans);
  return 0;
}
