Problem: Yaroslav calls an array of r integers a1, a2, ..., ar good, if it meets the following conditions: |a1 - a2| = 1, |a2 - a3| = 1, ..., |ar - 1 - ar| = 1, |ar - a1| = 1, at that <image>. 

An array of integers b1, b2, ..., br is called great, if it meets the following conditions:

  1. The elements in it do not decrease (bi ≤ bi + 1). 
  2. If the inequalities 1 ≤ r ≤ n and 1 ≤ bi ≤ m hold. 
  3. If we can rearrange its elements and get at least one and at most k distinct good arrays. 



Yaroslav has three integers n, m, k. He needs to count the number of distinct great arrays. Help Yaroslav! As the answer may be rather large, print the remainder after dividing it by 1000000007 (109 + 7).

Two arrays are considered distinct if there is a position in which they have distinct numbers.

Input

The single line contains three integers n, m, k (1 ≤ n, m, k ≤ 100).

Output

In a single line print the remainder after dividing the answer to the problem by number 1000000007 (109 + 7).

Examples

Input

1 1 1


Output

0


Input

3 3 3


Output

2

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
  if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
  if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
  char c, sg = 0;
  while (c = getchar(), (c > '9' || c < '0') && c != '-')
    ;
  for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
       c = getchar())
    first = (first << 1) + (first << 3) + c - '0';
  if (sg) first = -first;
}
template <class T>
inline void print(T first) {
  if (first < 0) {
    putchar('-');
    return print(-first);
  }
  if (first < 10) {
    putchar('0' + first);
    return;
  }
  print(first / 10);
  putchar(first % 10 + '0');
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
  gn(first);
  gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
  gn(first);
  gn(second);
  gn(z);
}
template <class T>
inline void println(T first) {
  print(first);
  putchar('\n');
}
template <class T>
inline void printsp(T first) {
  print(first);
  putchar(' ');
}
template <class T1, class T2>
inline void print(T1 x1, T2 x2) {
  printsp(x1), println(x2);
}
template <class T1, class T2, class T3>
inline void print(T1 x1, T2 x2, T3 x3) {
  printsp(x1), printsp(x2), println(x3);
}
template <class T1, class T2, class T3, class T4>
inline void print(T1 x1, T2 x2, T3 x3, T4 x4) {
  printsp(x1), printsp(x2), printsp(x3), println(x4);
}
int power(int a, int b, int m, int ans = 1) {
  for (; b; b >>= 1, a = 1LL * a * a % m)
    if (b & 1) ans = 1LL * ans * a % m;
  return ans;
}
int dp[55][55][55][55 << 1];
long long fac[55 << 1], re[55 << 1];
void add(int &u, int v) {
  u += v;
  if (u >= 1000000007) u -= 1000000007;
}
void pre() {
  fac[0] = re[0] = 1;
  for (int i = 1; i < 105; i++)
    fac[i] = fac[i - 1] * i % 1000000007,
    re[i] = power(fac[i], 1000000007 - 2, 1000000007);
}
int C(int n, int m) {
  return (long long)fac[n] * re[m] % 1000000007 * re[n - m] % 1000000007;
}
int main() {
  pre();
  int n, m, mx;
  gn(n, m, mx);
  int ans = 0;
  for (int i = 1; i <= n / 2; i++) dp[2][i][i][1] = 1;
  for (int i = 2; i <= n / 2 + 1 and i <= m; i++)
    for (int j = 1; j <= n / 2; j++) {
      int val;
      for (int k = 1; k <= n / 2; k++)
        for (int w = 1; w <= mx; w++)
          if (val = dp[i][j][k][w]) {
            add(ans, (long long)(m - i + 1) * val % 1000000007);
            for (int r = 1; r + j <= n / 2; r++) {
              long long ww = (long long)w * C(k + r - 1, r);
              if (ww > mx) break;
              add(dp[i + 1][j + r][r][ww], val);
            }
          }
    }
  println(ans);
  return 0;
}