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>
int n, m, p;
unsigned long long Pow[1000];
const unsigned long long b = 100007;
namespace solve1 {
std::map<unsigned long long, bool> m;
int flag[120][120];
void work() {}
}  // namespace solve1
namespace solve2 {
std::vector<int> ans[1000000];
int tot = 0;
unsigned long long hash[1000000];
int max[1000000];
void dfs(int now, std::vector<int> V) {
  if (now > n) return;
  std::vector<int> tmp;
  if (V[V.size() - 1] == 2) ans[++tot] = V;
  tmp = V;
  if (tmp[tmp.size() - 1] - 1 >= 1)
    tmp.push_back(tmp[tmp.size() - 1] - 1), dfs(now + 1, tmp);
  tmp = V;
  if (tmp[tmp.size() - 1] + 1 <= m)
    tmp.push_back(tmp[tmp.size() - 1] + 1), dfs(now + 1, tmp);
}
void work() {
  std::vector<int> v;
  v.push_back(1);
  dfs(1, v);
  std::map<unsigned long long, int> M;
  std::map<unsigned long long, int> U;
  for (int i = 1; i <= tot; i++) {
    hash[i] = 0;
    for (int j = 0; j < ans[i].size(); j++)
      hash[i] += Pow[ans[i][j]], max[i] = std::max(max[i], ans[i][j]);
    M[hash[i]]++;
  }
  int ans1 = 0;
  for (int i = 1; i <= tot; i++)
    if (!U[hash[i]]) {
      ans1 += (m - max[i] + 1);
      U[hash[i]]++;
    }
  std::cout << ans1;
}
}  // namespace solve2
namespace solve3 {
const int mod = 1e9 + 7;
inline long long add(long long a, long long b) {
  return (a += b) >= mod ? (a - mod) : a;
}
inline long long dec(long long a, long long b) {
  a -= b;
  return a + (a >> 31 & mod);
}
inline long long mul(long long a, long long b) {
  static long long r;
  r = 1ll * a * b;
  return (r >= mod) ? (r % mod) : r;
}
inline void Add(long long &a, long long b) { (a += b) >= mod ? (a -= mod) : 0; }
inline void Dec(long long &a, long long b) { a -= b, a += a >> 31 & mod; }
inline void Mul(long long &a, long long b) {
  static long long r;
  r = 1ll * a * b;
  a = (r >= mod) ? (r % mod) : r;
}
inline long long ksm(long long a, long long b, long long res = 1) {
  if (a == 0 && b == 0) return 0;
  for (; b; b >>= 1, Mul(a, a)) (b & 1) && (Mul(res, a), 1);
  return res;
}
inline long long Inv(long long x) { return ksm(x, mod - 2); }
inline long long fix(long long x) { return (x < 0) ? x + mod : x; }
const long long N = 105;
long long f[2][N][N][N], c[N][N];
void work() {
  long long K = p;
  for (long long i = 0; i < N; i++) {
    c[i][0] = c[i][i] = 1;
    for (long long j = 1; j < i; j++)
      c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
  }
  long long cur = 0, res = 0;
  for (long long i = 1; i <= m; i++) {
    cur ^= 1;
    memset(f[cur], 0, sizeof(f[cur]));
    for (long long j = 1; j <= n; j++)
      for (long long k = 1; k <= j; k++)
        for (long long l = 1; l <= K; l++)
          if (f[cur ^ 1][j][k][l]) {
            long long now = f[cur ^ 1][j][k][l];
            for (long long p = k; j + p <= n && l * c[p - 1][k - 1] <= K; p++) {
              Add(f[cur][j + p][p - k][l * c[p - 1][k - 1]], now);
            }
          }
    for (long long j = 1; j <= n; j++) Add(f[cur][j][j][1], 1);
    for (long long j = 1; j <= n; j++)
      for (long long k = 1; k <= K; k++) Add(res, f[cur][j][0][k]);
  }
  std::cout << res << '\n';
}
}  // namespace solve3
signed main() {
  scanf("%d%d%d", &n, &m, &p);
  Pow[0] = 1;
  for (long long i = 1; i <= 100; i++) Pow[i] = b * Pow[i - 1];
  solve3::work();
}