Quite recently a creative student Lesha had a lecture on trees. After the lecture Lesha was inspired and came up with the tree of his own which he called a *k*-tree.

A *k*-tree is an infinite rooted tree where:
 -  each vertex has exactly *k* children; -  each edge has some weight; -  if we look at the edges that goes from some vertex to its children (exactly *k* edges), then their weights will equal 1, 2, 3, ..., *k*. 
The picture below shows a part of a 3-tree.

 

 <img class="tex-graphics" src="https://espresso.codeforces.com/61ac5ac17c4d2f220968eff8fb59bb3c8dc77edf.png" style="max-width: 100.0%;max-height: 100.0%;"/>

 

Help Dima find an answer to his question. As the number of ways can be rather large, print it modulo 1000000007 (10<sup class="upper-index">9</sup> + 7).
A single line contains three space-separated integers: *n*, *k* and *d* (1 ≤ *n*, *k* ≤ 100; 1 ≤ *d* ≤ *k*).
// author: Nardos Wehabe

#include <bits/stdc++.h>

using namespace std;

void solve()
{
    int N, K, D;
    int MOD = 1e9 + 7;
    cin >> N >> K >> D;
    unordered_map<int, pair<int, int>> dp;
    if(D > 1) dp[1] = {1, 0};
    else dp[1] = {0, 1};
    function<pair<int, int>(int)> helper;
    helper = [&](int n){
        if(dp.count(n)) return dp[n];
        pair<int, int>  ret = {0, 0};
        for(int i = 1; i <= K && i < n; ++i){
            auto cnt = helper(n - i);
            ret.second += cnt.second;
            ret.second %= MOD;
            if(i >= D){
                ret.second += cnt.first;
                ret.second %= MOD;
            }
            else{
                ret.first += cnt.first;
                ret.first %= MOD;
            }
        }
        if(n <= K){
            if(n >= D){
                ret.second++;
            }
            else{
                ret.first++;
            }
        }
        dp[n] = ret;
        return ret;
    };

    cout << helper(N).second%MOD << "\n";

}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);

    int tt;
    // cin >> tt;
    tt = 1;

    while (tt--)
    {
        solve();
    }
    
    return 0;
}
