// Original C++ solution (slower):
#include<iostream>

#include<algorithm>

#include<vector>

#include<string>

#include<set>

#include<queue>

#include<stack>

#include<bitset>

#include<unordered_map>

#include<functional>

#include<map>

#include<iomanip>

#include<limits>

#include<unordered_set>

#include<cmath>

#include <numeric>

#include <array>

#include<utility>

#include <complex>

#define M_PI 3.141592653589793238

using namespace std;

long long p9 = 998244353;

long long p1 = 1000000007;

#define upperbound(v,val) upper_bound(v.begin(),v.end(),val)-v.begin()

#define lowerbound(v,val) lower_bound(v.begin(),v.end(),val)-v.begin()

#define int long long

#define vel vector<long long>

#define vvel vector<vel>

#define rep(i,n) for(int i=0;i<n;i++)

#define sor(v) sort(v.begin(),v.end())

#define mmax(a,b) a=max(a,b)

#define mmin(a,b) a=min(a,b)

#define mkp(a,b) make_pair(a,b)

#define pin pair<int,int>

#define qin pair<pin,int>

#define V vector

#define Endl endl

#define veb vector<bool>

#define fcout cout << fixed << setprecision(15)

#define rev(s) reverse(s.begin(),s.end())

#define lower(h,val) (lower_bound(h.begin(),h.end(),val)-h.begin())

#define upper(h,val) (upper_bound(h.begin(),h.end(),val)-h.begin())

#define vveb V<veb>

#define omajinai cin.tie(0);ios::sync_with_stdio(false);

#define endl "\n"

#define pb push_back

vel kai;

vel inv_kai;

vel inv;

int root(int x, vel& pa) {

	if (pa[x] == -1) { return x; }

	int ans = root(pa[x], pa); pa[x] = ans;

	return ans;

}

bool mar(int x, int y, vel& pa) {

	x = root(x, pa);

	y = root(y, pa);

	if (x != y) { pa[x] = y; }

	return (x != y);

}

int gcd(int x, int y) {

	if (x < y) { return gcd(y, x); }

	if (y == 0) { return x; }

	return gcd(y, x % y);

}

int lcm(int x, int y) {

	x = abs(x); y = abs(y);

	return x * (y / gcd(x, y));

}

long long modinv(long long a, long long m) {

	long long b = m, u = 1, v = 0;

	while (b) {

		long long t = a / b;

		a -= t * b; swap(a, b);

		u -= t * v; swap(u, v);

	}

	u %= m;

	if (u < 0) u += m;

	return u;

}

void make_inv(int max_inv, int p) {

	inv = vel(max_inv + 1, 1);

	for (int i = 2; i <= max_inv; i++) {

		inv[i] = p - ((p / i) * inv[p % i]) % p;

	}

}

void make_kai(int max_kai, int p) {

	kai = vel(max_kai + 1, 1);

	inv_kai = kai;

	make_inv(max_kai, p);

	rep(i, max_kai) {

		kai[i + 1] = kai[i] * (i + 1); kai[i + 1] %= p;

		inv_kai[i + 1] = inv_kai[i] * inv[i + 1]; inv_kai[i + 1] %= p;

	}

}

int com(int n, int r, int p) {

	if ((n < 0) || (r < 0) || (r > n)) { return 0; }

	int ans = (kai[n] * inv_kai[r]) % p;

	return (ans * inv_kai[n - r]) % p;

}

int per(int n, int r, int p) {

	if ((n < 0) || (r < 0) || (r > n)) { return 0; }

	return (kai[n] * inv_kai[n - r]) % p;

}

vel dijk(V<V<pin>>& way, int st, int inf) {

	int n = way.size();

	vel dist(n, inf); dist[st] = 0;

	priority_queue<pin, vector<pin>, greater<pin>> pq;

	pq.push(mkp(0, st));

	veb is_checked(n, false);

	while (!pq.empty()) {

		pin x = pq.top(); pq.pop();

		int pot = x.second;

		if (!is_checked[pot]) {

			is_checked[pot] = true;

			for (auto y : way[pot]) {

				int nex_dist = x.first + y.second;

				int nex_pot = y.first;

				if (dist[nex_pot] > nex_dist) {

					dist[nex_pot] = nex_dist;

					pq.push(mkp(nex_dist, y.first));

				}

			}

		}

	}

	return dist;

}

V<V<pin>> make_w(vvel v) {

	int n = v.size();

	V<V<pin>> ret(n);

	rep(i, n) {

		for (int x : v[i]) {

			ret[i].push_back(mkp(x, 1));

		}

	}

	return ret;

}

void make_tree(vvel& chi, vel& par, int n) {

	V<V<pin>> way(n);

	rep(i, n - 1) {

		int a, b; cin >> a >> b; a--; b--;

		way[a].push_back(mkp(b, 1));

		way[b].push_back(mkp(a, 1));

	}

	vel dist = dijk(way, 0, n + 1);

	par = vel(n, -1);

	chi = vvel(n);

	rep(i, n) {

		for (auto nex : way[i]) {

			int pot = nex.first;

			if (dist[pot] > dist[i]) { chi[i].push_back(pot); }

			else { par[i] = pot; }

		}

	}

}

void pri(vel& v) {

	if (v.size() == 0) { return; }

	cout << v[0];

	rep(i, v.size() - 1) { cout << " " << v[i + 1]; }

	cout << endl;

	return;

}

int modpow(int a, int n, int p) {

	if (n == 0) { return 1; }

	int m = n / 2;

	int x = modpow(a, n / 2, p);

	x *= x; x %= p;

	if (n % 2 == 1) { x *= a; x %= p; }

	return x;

}

#define ui long long

vvel disj_min(vel& v) {

	int n = v.size();

	vvel ret(22, vel(n));

	ret[0] = v;

	rep(i, 21) {

		rep(j, n) {

			int nex = j + (1 << i);

			if (nex < n) {

				ret[i + 1][j] = min(ret[i][j], ret[i][nex]);

			}

			else {

				ret[i + 1][j] = ret[i][j];

			}

		}

	}

	return ret;

}

int find_min(vvel& dv, int l, int r) {

	int i = 21;

	while (l + (1 << i) > r) {

		i--;

	}

	while (i >= 0) {

		if (dv[i][l] > dv[i][r - (1 << i)]) {

			l = r - (1 << i);

		}

		else {

			r = l + (1 << i);

		}

		i--;

	}

	return l;

}

V<V<pin>> dbl(V<pin>& v) {

	V<V<pin>> ans(20, V<pin>(v));

	int n = v.size();

	rep(i, 19) {

		rep(j, n) {

			ans[i + 1][j].first = ans[i][ans[i][j].first].first;

			ans[i + 1][j].second = max(ans[i][j].second, ans[i][ans[i][j].first].second);

		}

	}

	return ans;

}

int lca(int s, int t, int diff, V<V<pin>>& pa) {

	if (diff < 0) { return lca(t, s, -diff, pa); }

	int ans = 0;

	rep(i, 19) {

		if ((diff & (1 << i)) != 0) {

			mmax(ans, pa[i][s].second);

			s = pa[i][s].first;

		}

	}

	for (int i = 19; i >= 0; i--) {

		if (pa[i][s] != pa[i][t]) {

			mmax(ans, pa[i][s].second);

			s = pa[i][s].first;

			mmax(ans, pa[i][t].second);

			t = pa[i][t].first;

		}

	}

	if (s != t) {

		mmax(ans, pa[0][s].second);

		mmax(ans, pa[0][t].second);

	}

	return ans;

}

void alp(int n, vel& pr) {

	for (int i = 2; i * i <= n; i++) {

		if (n % i == 0) {

			pr.push_back(i);

			while (n % i == 0) { n /= i; }

		}

	}

	if (n != 1) { pr.push_back(n); }

}

vel dx = { 0,0,-1,1 };

vel dy = { 1,-1,0,0 };

void sol(int i,int st,int dir,vel&cnt, vvel& nex,vvel& use) {

	if (use[i].size() == 0 || use[i].back() != st) {

		use[i].push_back(st);

		if (cnt[i] >= 1) {

			rep(nd, 2) {

				int ne = nex[nd][i];

				if(ne!=-1){

					sol(ne, st, nd, cnt, nex, use);

				}

			}

		}

		else {

			int ne = nex[dir][i];

			if (ne != -1) {

				sol(ne, st, dir, cnt, nex, use);

			}

		}

	}

}

signed main() {

	omajinai;

	int n, h, d; cin >> n >> h >> d;

	make_kai(n + 1, p1);

	int M = 0;

	rep(i, n) {

		M += kai[i + 1];

		M %= p1;

	}

	vel dp(h);

	dp[0] = 1;

	for (int i = 1; i < h; i++) {

		dp[i] = (M+1) * dp[i - 1];

		if (i >= d + 1) {

			dp[i] -= M * dp[i - d - 1];

		}

		dp[i] %= p1; dp[i] += p1; dp[i] %= p1;

	}

	int ans = dp.back();

	if (h >= d + 1) {

		ans += p1 - dp[h - d - 1];

	}

	ans *= kai[n];

	cout << ans % p1 << endl;

	return 0;

}

// Optimized solution to the same problem (faster):
#include<iostream>

#include<algorithm>

#include<vector>

#include<string>

#include<set>

#include<queue>

#include<stack>

#include<bitset>

#include<unordered_map>

#include<functional>

#include<map>

#include<iomanip>

#include<limits>

#include<unordered_set>

#include<cmath>

#include <numeric>

#include <array>

#include<utility>

#include <complex>

#define M_PI 3.141592653589793238

using namespace std;

long long p9 = 998244353;

long long p1 = 1000000007;

#define upperbound(v,val) upper_bound(v.begin(),v.end(),val)-v.begin()

#define lowerbound(v,val) lower_bound(v.begin(),v.end(),val)-v.begin()

#define int long long

#define vel vector<long long>

#define vvel vector<vel>

#define rep(i,n) for(int i=0;i<n;i++)

#define sor(v) sort(v.begin(),v.end())

#define mmax(a,b) a=max(a,b)

#define mmin(a,b) a=min(a,b)

#define mkp(a,b) make_pair(a,b)

#define pin pair<int,int>

#define qin pair<pin,int>

#define V vector

#define Endl endl

#define veb vector<bool>

#define fcout cout << fixed << setprecision(15)

#define rev(s) reverse(s.begin(),s.end())

#define lower(h,val) (lower_bound(h.begin(),h.end(),val)-h.begin())

#define upper(h,val) (upper_bound(h.begin(),h.end(),val)-h.begin())

#define vveb V<veb>

#define omajinai cin.tie(0);ios::sync_with_stdio(false);

#define endl "\n"

#define pb push_back

vel kai;

vel inv_kai;

vel inv;

int root(int x, vel& pa) {

	if (pa[x] == -1) { return x; }

	int ans = root(pa[x], pa); pa[x] = ans;

	return ans;

}

bool mar(int x, int y, vel& pa) {

	x = root(x, pa);

	y = root(y, pa);

	if (x != y) { pa[x] = y; }

	return (x != y);

}

int gcd(int x, int y) {

	if (x < y) { return gcd(y, x); }

	if (y == 0) { return x; }

	return gcd(y, x % y);

}

int lcm(int x, int y) {

	x = abs(x); y = abs(y);

	return x * (y / gcd(x, y));

}

long long modinv(long long a, long long m) {

	long long b = m, u = 1, v = 0;

	while (b) {

		long long t = a / b;

		a -= t * b; swap(a, b);

		u -= t * v; swap(u, v);

	}

	u %= m;

	if (u < 0) u += m;

	return u;

}

void make_inv(int max_inv, int p) {

	inv = vel(max_inv + 1, 1);

	for (int i = 2; i <= max_inv; i++) {

		inv[i] = p - ((p / i) * inv[p % i]) % p;

	}

}

void make_kai(int max_kai, int p) {

	kai = vel(max_kai + 1, 1);

	inv_kai = kai;

	make_inv(max_kai, p);

	rep(i, max_kai) {

		kai[i + 1] = kai[i] * (i + 1); kai[i + 1] %= p;

		inv_kai[i + 1] = inv_kai[i] * inv[i + 1]; inv_kai[i + 1] %= p;

	}

}

int com(int n, int r, int p) {

	if ((n < 0) || (r < 0) || (r > n)) { return 0; }

	int ans = (kai[n] * inv_kai[r]) % p;

	return (ans * inv_kai[n - r]) % p;

}

int per(int n, int r, int p) {

	if ((n < 0) || (r < 0) || (r > n)) { return 0; }

	return (kai[n] * inv_kai[n - r]) % p;

}

vel dijk(V<V<pin>>& way, int st, int inf) {

	int n = way.size();

	vel dist(n, inf); dist[st] = 0;

	priority_queue<pin, vector<pin>, greater<pin>> pq;

	pq.push(mkp(0, st));

	veb is_checked(n, false);

	while (!pq.empty()) {

		pin x = pq.top(); pq.pop();

		int pot = x.second;

		if (!is_checked[pot]) {

			is_checked[pot] = true;

			for (auto y : way[pot]) {

				int nex_dist = x.first + y.second;

				int nex_pot = y.first;

				if (dist[nex_pot] > nex_dist) {

					dist[nex_pot] = nex_dist;

					pq.push(mkp(nex_dist, y.first));

				}

			}

		}

	}

	return dist;

}

V<V<pin>> make_w(vvel v) {

	int n = v.size();

	V<V<pin>> ret(n);

	rep(i, n) {

		for (int x : v[i]) {

			ret[i].push_back(mkp(x, 1));

		}

	}

	return ret;

}

void make_tree(vvel& chi, vel& par, int n) {

	V<V<pin>> way(n);

	rep(i, n - 1) {

		int a, b; cin >> a >> b; a--; b--;

		way[a].push_back(mkp(b, 1));

		way[b].push_back(mkp(a, 1));

	}

	vel dist = dijk(way, 0, n + 1);

	par = vel(n, -1);

	chi = vvel(n);

	rep(i, n) {

		for (auto nex : way[i]) {

			int pot = nex.first;

			if (dist[pot] > dist[i]) { chi[i].push_back(pot); }

			else { par[i] = pot; }

		}

	}

}

void pri(vel& v) {

	if (v.size() == 0) { return; }

	cout << v[0];

	rep(i, v.size() - 1) { cout << " " << v[i + 1]; }

	cout << endl;

	return;

}

int modpow(int a, int n, int p) {

	if (n == 0) { return 1; }

	int m = n / 2;

	int x = modpow(a, n / 2, p);

	x *= x; x %= p;

	if (n % 2 == 1) { x *= a; x %= p; }

	return x;

}

#define ui long long

vvel disj_min(vel& v) {

	int n = v.size();

	vvel ret(22, vel(n));

	ret[0] = v;

	rep(i, 21) {

		rep(j, n) {

			int nex = j + (1 << i);

			if (nex < n) {

				ret[i + 1][j] = min(ret[i][j], ret[i][nex]);

			}

			else {

				ret[i + 1][j] = ret[i][j];

			}

		}

	}

	return ret;

}

int find_min(vvel& dv, int l, int r) {

	int i = 21;

	while (l + (1 << i) > r) {

		i--;

	}

	while (i >= 0) {

		if (dv[i][l] > dv[i][r - (1 << i)]) {

			l = r - (1 << i);

		}

		else {

			r = l + (1 << i);

		}

		i--;

	}

	return l;

}

V<V<pin>> dbl(V<pin>& v) {

	V<V<pin>> ans(20, V<pin>(v));

	int n = v.size();

	rep(i, 19) {

		rep(j, n) {

			ans[i + 1][j].first = ans[i][ans[i][j].first].first;

			ans[i + 1][j].second = max(ans[i][j].second, ans[i][ans[i][j].first].second);

		}

	}

	return ans;

}

int lca(int s, int t, int diff, V<V<pin>>& pa) {

	if (diff < 0) { return lca(t, s, -diff, pa); }

	int ans = 0;

	rep(i, 19) {

		if ((diff & (1 << i)) != 0) {

			mmax(ans, pa[i][s].second);

			s = pa[i][s].first;

		}

	}

	for (int i = 19; i >= 0; i--) {

		if (pa[i][s] != pa[i][t]) {

			mmax(ans, pa[i][s].second);

			s = pa[i][s].first;

			mmax(ans, pa[i][t].second);

			t = pa[i][t].first;

		}

	}

	if (s != t) {

		mmax(ans, pa[0][s].second);

		mmax(ans, pa[0][t].second);

	}

	return ans;

}

void alp(int n, vel& pr) {

	for (int i = 2; i * i <= n; i++) {

		if (n % i == 0) {

			pr.push_back(i);

			while (n % i == 0) { n /= i; }

		}

	}

	if (n != 1) { pr.push_back(n); }

}

vel dx = { 0,0,-1,1 };

vel dy = { 1,-1,0,0 };

void sol(int i, int st, int dir, vel& cnt, vvel& nex, vvel& use) {

	if (use[i].size() == 0 || use[i].back() != st) {

		use[i].push_back(st);

		if (cnt[i] >= 1) {

			rep(nd, 2) {

				int ne = nex[nd][i];

				if (ne != -1) {

					sol(ne, st, nd, cnt, nex, use);

				}

			}

		}

		else {

			int ne = nex[dir][i];

			if (ne != -1) {

				sol(ne, st, dir, cnt, nex, use);

			}

		}

	}

}

signed main() {

	omajinai;

	int n, h, d; cin >> n >> h >> d;

	int M = 0;

	vel dp(h);

	dp[0] =1;

	rep(i, n) {

		dp[0] *= (i + 1); dp[0] %= p1;

		M += dp[0];

		M %= p1;

	}

	for (int i = 1; i < h; i++) {

		dp[i] = (M + 1) * dp[i - 1];

		if (i >= d + 1) {

			dp[i] -= M * dp[i - d - 1];

		}

		dp[i] %= p1; 

		if (dp[i] < 0) { dp[i] += p1; }

	}

	int ans = dp.back();

	if (h >= d + 1) {

		ans -= dp[h - d - 1];

		if (ans < 0) { ans += p1; }

	}

	cout << ans << endl;

	return 0;

}


// Fastest known solution for this problem: