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*).
import time
import sys
import math
mod, infi = 1000000007, sys.maxsize
from collections import deque, Counter, defaultdict as dd
from itertools import accumulate
from functools import lru_cache, reduce
from operator import mul, add, sub, truediv, floordiv, lt, le, eq, ne, gt, xor, concat, getitem, pow, lshift
inty    =lambda: int(input())
stringy =lambda: input().strip()
mappy   =lambda: map(int,input().strip().split())
fmappy  =lambda: map(float,input().strip().split())
listy   =lambda: list(map(int,input().strip().split()))
sys.setrecursionlimit(10**6)
tick    =lambda: time.perf_counter()
logg    =lambda a, b: math.log2(a) / math.log2(b)
acc     =lambda x: list(accumulate(x))
sign    =lambda x, y: x >= 0 and y >= 0 or x < 0 and y < 0
npr     =lambda n, r: math.factorial(n) // (math.factorial(n - r))
ncr     =lambda n, r: math.factorial(n) // (math.factorial(n - r) * math.factorial(r))

n, k, d = mappy()
dp = [[0] * 2 for _  in range(100)]
dp[0][0] = 1
def add(a, b):
    a += b
    a = a % mod
    return a
for i in range(1, n + 1):
    dp[i][0] = dp[i][1] = 0
    for j in range(1, k + 1):
        if i - j < 0: break

        if j < d:
            dp[i][0] = add(dp[i][0], dp[i - j][0])
            dp[i][1] = add(dp[i][1], dp[i - j][1])
        
        else:
            dp[i][1] = add(dp[i][1], dp[i-j][0])
            dp[i][1] = add(dp[i][1], dp[i-j][1])
print(dp[n][1])