#include <bits/stdc++.h>
using namespace std;
namespace mint {
  int md = 1e9 + 7;
  inline void add (int &a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    a += b; if (a >= md) a -= md;
  }
  inline void sub (int &a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    a -= b; if (a < 0) a += md;
  }
  inline int sum (int a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    add(a, b); return a;
  }
  inline int dif (int a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    sub(a, b); return a;
  }
  template<class... A>
  inline int prod (A... args) {
    long long ret = 1;
    for (int a :	initializer_list<int>{args...}) {
      assert(0 <= a && a < md);
      ret *= a;
      ret %= md;
    }
    return (int)(ret % md);
  }
  inline void mul (int &a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    a = prod(a, b);
  }
  inline int inv (int a) {
    assert(0 <= a && a < md);
    a %= md;
    if(a < 0) a += md;
    int b = md, u = 0, v = 1;
    while (a) {
      int t = b / a;
      b -= a * t; swap(a, b);
      u -= v * t; swap(u, v);
    }
    assert(b == 1);
    if(u < 0) u += md;
    return u;
  }
  inline int quot (int a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    return prod(a, inv(b));
  }
  inline void div (int& a, int b) {
    assert(0 <= a && a < md && 0 <= b && b < md);
    a = quot(a, b);
  }
  inline int pow (int a, long long b) {
    assert(0 <= a && a < md);
    int res = 1;
    for (; b; b >>= 1) {
      if (b & 1) mul(res, a);
      mul(a, a);
    }
    return res;
  }
  namespace factorials {
    int sz;
    vector<int> fact, finv;
    void init (int n) {
      sz = n;
      fact.resize(n); finv.resize(n);
      fact[0] = 1;
      for (int i = 1; i < n; i++) fact[i] = prod(fact[i - 1], i);
      finv[n - 1] = inv(fact[n - 1]);
      for (int i = n - 2; i >= 0; i--) finv[i] = prod(finv[i + 1], i + 1);
    }
  }
  inline int fct (int i) {
    using namespace factorials;
    assert(0 <= i && i < sz);
    return fact[i];
  }
  inline int fnv (int i) {
    using namespace factorials;
    assert(0 <= i && i < sz);
    return finv[i];
  }
  inline int binom (int n, int k) {
    using namespace factorials;
    assert(0 <= n && n < sz);
    if (0 < k || n < k) return 0;
    return prod(fact[n], finv[k], finv[n - k]);
  }
}
template <typename T>
class binary_indexed_tree {
  int sz;
  vector<T> tr;
  function<T(T, T)> o;
  function<T(T, T)> dif;
  T id;
  public:
    binary_indexed_tree (
      int n
    , function<T(T, T) > o = [](int a, int b) {return a + b;}
    , function<T(T, T) > dif = [](int a, int b) {return a - b;}
    , T id = 0
    )
    : sz(n)
    , tr(n, id)
    , o(o)
    , dif(dif)
    , id(id)
    {
    }
    T query (int l, int r) {
      assert(0 <= l && l <= r && r <= sz);
      if (l == 0) {
        r--;
        T ret = 0;
        for (; r >= 0; r &= r + 1, r--) ret = o(ret, tr[r]);
        return ret;
      }
      return dif(query(0, r), query(0, l));
    }
    void add (int i, T x) {
      for (; i < sz; i |= i + 1) tr[i] = o(tr[i], x);
    }
    void print() {
      cout << "bit: ";
      for (int i = 0; i < sz; i++) {
        cout << query(i, i + 1);
        if (i == sz - 1) break;
        cout << ' ';
      }
      cout << endl;
    }
};
int main() {
  cin.tie(0); cin.sync_with_stdio(false);
  int n, h, d;
  cin >> n >> h >> d;
  mint::factorials::init(n + 1);
  int B = 0;
  for (int i = 1; i <= n; i++) {
    mint::add(B, mint::fct(i));
  }
  binary_indexed_tree<int> bit(
    h,
    [](int x, int y) {return mint::sum(x, y);},
    [](int x, int y) {return mint::dif(x, y);}
  );
  bit.add(0, 1);
  for (int i = 1; i < h; i++) {
    bit.add(i, mint::prod(
      bit.query(max(0, i - d), i),
      B
    ));
  }
  int ret = mint::prod(
    bit.query(h - d, h),
    mint::fct(n)
  );
  cout << ret << endl;
  return 0;
}

Measured memory_bytes: 12032