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 JAVA):

Solution:
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.ArrayList;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author sheep
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		InputReader in = new InputReader(inputStream);
		PrintWriter out = new PrintWriter(outputStream);
		TaskE solver = new TaskE();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskE {

    int ptrNumbers;
    int numbers[];
    int primes[];

    void dfs(int depth, int now, int maxCont, int count) {
        if (depth == primes.length) {
            if (maxCont + count <= 100) {
                numbers[ptrNumbers++] = now;
            }
            return;
        }

        boolean enable = (primes[depth] * primes[depth]) > 100;
        for (int i = 0; ; ++i) {
            dfs(depth + 1, now, i == 0 ? maxCont : primes[depth], enable ? count + i : count);
            if (now * (long)primes[depth] > 1000000000) {
                break;
            }
            now *= primes[depth];
        }
    }

    void find() {
        ArrayList<Integer> primes = new ArrayList<Integer>();
        for (int i = 2; i <= 100; ++i) {
            boolean isPrime = true;
            for (int j = 2; j < i; ++j) {
                if (i % j == 0) {
                    isPrime = false;
                }
            }

            if (isPrime) {
                primes.add(i);
            }
        }

        this.primes = new int[primes.size()];
        for (int i = 0; i < primes.size(); ++i) {
            this.primes[i] = primes.get(i);
        }

        numbers = new int[2759075];
        ptrNumbers = 0;
        dfs(0, 1, 1, 0);

        Arrays.sort(numbers);
    }

    int leastNeed[];
    boolean included[];

    public void solve(int testNumber, InputReader in, PrintWriter out) {
        find();
        leastNeed = new int[ptrNumbers];
        included = new boolean[ptrNumbers];
        Arrays.fill(leastNeed, Integer.MAX_VALUE / 100);

        int l = in.nextInt();
        int r = in.nextInt();
        int maxSteps = in.nextInt();

        leastNeed[0] = 0;

        int ans = 0;
        for (int i = 0; i < ptrNumbers; ++i) {
            if (numbers[i] < l || numbers[i] > r) {
                included[i] = true;
            }
        }

        for (int i = 2; i < maxSteps; ++i) {

            int leftPtr = 0;
            for (int j = 0; j < ptrNumbers; ++j) {

                while (numbers[leftPtr] * i < numbers[j]) {
                    ++leftPtr;
                }

                if (numbers[leftPtr] * (long)i == numbers[j]) {

                    if (leastNeed[leftPtr] + 1 < leastNeed[j]) {

                        leastNeed[j] = leastNeed[leftPtr] + 1;

                        if (!included[j]) {
                            if (leastNeed[j] + i <= maxSteps) {
                                ++ans;
                                included[j] = true;
                            }
                        }
                    }
                }
            }
        }

        out.println(ans);
    }
}

class InputReader {
    BufferedReader reader;
    StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    }