Problem: Maxim has got a calculator. The calculator has two integer cells. Initially, the first cell contains number 1, and the second cell contains number 0. In one move you can perform one of the following operations:

  1. Let's assume that at the current time the first cell contains number a, and the second cell contains number b. Write to the second cell number b + 1; 
  2. Let's assume that at the current time the first cell contains number a, and the second cell contains number b. Write to the first cell number a·b. 



Maxim is wondering, how many integers x (l ≤ x ≤ r) are there, such that we can write the number x to the first cell of the calculator, having performed at most p moves.

Input

The first line contains three integers: l, r, p (2 ≤ l ≤ r ≤ 109, 1 ≤ p ≤ 100). 

The numbers in the line are separated by single spaces.

Output

In a single line print a single integer — the answer to the problem.

Examples

Input

2 10 3


Output

1


Input

2 111 100


Output

106


Input

2 111 11


Output

47

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(0.0) * 2.0;
const double eps = 1e-12;
const int step[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
template <class T>
inline T abs1(T a) {
  return a < 0 ? -a : a;
}
template <class T>
inline T max1(T a, T b) {
  return a > b ? a : b;
}
template <class T>
inline T min1(T a, T b) {
  return a < b ? a : b;
}
template <class T>
inline T gcd1(T a, T b) {
  if (a < b) swap(a, b);
  if (a % b == 0) return b;
  return gcd1(b, a % b);
}
template <class T>
inline T lb(T num) {
  return num & (-num);
}
inline int jud(double a, double b) {
  if (abs1(a - b) < eps) return 0;
  if (a < b) return -1;
  return 1;
}
template <class t>
inline int find(int val, t *a, int na, bool f_small = 1, bool f_lb = 1) {
  if (na == 1) return 0;
  int be = 0, en = na - 1;
  if (a[0] <= a[na - 1]) {
    if (f_lb == 0)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(a[mid], val) != 1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(a[mid], val) != -1)
          en = mid;
        else
          be = mid + 1;
      }
    if (f_small && a[be] > val && be != 0) be--;
    if (!f_small && a[be] < val && be != na - 1) be++;
  } else {
    if (f_lb)
      while (be < en) {
        int mid = (be + en + 1) / 2;
        if (jud(a[mid], val) != -1)
          be = mid;
        else
          en = mid - 1;
      }
    else
      while (be < en) {
        int mid = (be + en) / 2;
        if (jud(a[mid], val) != 1)
          en = mid;
        else
          be = mid + 1;
      }
    if (!f_small && a[be] < val && be != 0) be--;
    if (f_small && a[be] > val && be != na - 1) be++;
  }
  return be;
}
inline int bitnum(unsigned long long nValue) {
  nValue = ((0xaaaaaaaaaaaaaaaaull & nValue) >> 1) +
           (0x5555555555555555ull & nValue);
  nValue = ((0xccccccccccccccccull & nValue) >> 2) +
           (0x3333333333333333ull & nValue);
  nValue = ((0xf0f0f0f0f0f0f0f0ull & nValue) >> 4) +
           (0x0f0f0f0f0f0f0f0full & nValue);
  nValue = ((0xff00ff00ff00ff00ull & nValue) >> 8) +
           (0x00ff00ff00ff00ffull & nValue);
  nValue = ((0xffff0000ffff0000ull & nValue) >> 16) +
           (0x0000ffff0000ffffull & nValue);
  nValue = ((0xffffffff00000000ull & nValue) >> 32) +
           (0x00000000ffffffffull & nValue);
  return nValue;
}
long long pow(long long n, long long m, long long mod = 0) {
  long long ans = 1;
  long long k = n;
  while (m) {
    if (m & 1) {
      ans *= k;
      if (mod) ans %= mod;
    }
    k *= k;
    if (mod) k %= mod;
    m >>= 1;
  }
  return ans;
}
const int inf = 1000000000;
const int maxn = 3000000;
long long l, r, p;
long long pri[100], lpri;
long long num[maxn], lnum;
long long dp[maxn][2];
void dfs(long long val, int minl) {
  if (pri[minl] > p) return;
  for (long long i = 0, val1 = val; val1 <= r; val1 *= pri[minl], i++) {
    if (i) num[lnum++] = val1;
    dfs(val1, minl + 1);
  }
}
int main() {
  scanf("%I64d%I64d%I64d", &l, &r, &p);
  pri[lpri++] = 2;
  for (int i = 3, j = 0; i < 100; i += 2, j = 0) {
    for (; j < lpri; j++)
      if (i % pri[j] == 0) break;
    if (j == lpri) pri[lpri++] = i;
  }
  pri[lpri++] = inf;
  dfs(1, 0);
  num[lnum++] = 1;
  sort(num, num + lnum);
  for (int i = 2; i <= min1(100ll, p); i++) {
    int link2 = 0;
    int max1 = r / i;
    for (int j = 0; num[j] <= max1; j++) {
      if (!dp[j][0] && j) continue;
      while (num[link2] < num[j] * i) link2++;
      if (num[link2] == num[j] * i) {
        if (dp[link2][0] == 0 || dp[link2][0] > dp[j][0] + 1)
          dp[link2][0] = dp[j][0] + 1;
        if (dp[link2][1] == 0 || dp[link2][1] > dp[link2][0] + i)
          dp[link2][1] = dp[link2][0] + i;
      }
    }
  }
  int ans1 = 0, ans2 = 0;
  for (int i = 0; i < lnum && num[i] < l; i++)
    if (dp[i][1] <= p) ans1++;
  for (int i = 0; i < lnum; i++)
    if (dp[i][1] <= p) ans2++;
  cout << ans2 - ans1 << endl;
  return 0;
}