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
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.io.InputStream;

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

class TaskE {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        long l = in.readLong();
        long r = in.readLong();
        int p = in.readInt();

        boolean[] is_prime = Prime.GetIsPrimeList(100);
        long[] v = new long[3000000];
        v[0] = 1;
        int e = 1;
        for (int i = 2; i < 100; ++i) {
            if (is_prime[i]) {
                int ee = e;
                for (int j = 0; j < ee; ++j) {
                    long temp = v[j];
                    while (temp * i <= r) {
                        temp *= i;
                        v[e++] = temp;
                    }
                }
            }
        }
        long[] D = new long[v.length];
        boolean [] good = new boolean[D.length];

        Arrays.sort(v, 0, e);

        for (int i = 1; i < e; ++i) {
            D[i] = 200;
        }
        good[0] = true;

        for (int i = 2; i <= p; ++i) {
            int j = 0;
            int k = 0;
            while (true) {
                long temp = v[j] * i;
                while (k < e && v[k] < temp) k++;
                if (k == e) break;
                if (v[k] == temp && D[k] > D[j] + 1) {
                    D[k] = D[j] + 1;
                    if (D[k] + i <= p) {
                        good[k] = true;
                    }
                }
                j++;
            }
        }
        long res = 0;
        for (int i = 0; i < e; ++i) {
            if (l <= v[i] && v[i] <= r && good[i]) {
                res++;
            }
        }
        out.printLine(res);
    }
}

class InputReader {

    private InputStream stream;
    private byte[] buf = new byte[1024];
    private int curChar;
    private int numChars;

    public InputReader(InputStream stream) {
        this.stream = stream;
    }

    public int read() {
        // InputMismatchException -> UnknownError
        if (numChars == -1)
            throw new UnknownError();
        if (curChar >= numChars) {
            curChar = 0;
            try {
                numChars = stream.read(buf);
            } catch (IOException e) {
                throw new UnknownError();
            }
            if (numChars <= 0)
                return -1;
        }
        return buf[curChar++];
    }

    public int readInt() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        } else if (c == '+') {
            c = read();
        }
        int res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public long readLong() {
        int c = read();
        while (isSpaceChar(c))
            c = read();
        int sgn = 1;
        if (c == '-') {
            sgn = -1;
            c = read();
        }
        long res = 0;
        do {
            if (c < '0' || c > '9')
                throw new InputMismatchException();
            res *= 10;
            res += c - '0';
            c = read();
        } while (!isSpaceChar(c));
        return res * sgn;
    }

    public static boolean isSpaceChar(int c) {
        return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
    }

    }

class OutputWriter {
    private final PrintWriter writer;

    public OutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(outputStream);
    }

    public OutputWriter(Writer writer) {
        this.writer = new PrintWriter(writer);
    }

    public void print(Object...objects) {
        for (int i = 0; i < objects.length; i++) {
            if (i != 0)
                writer.print(' ');
            writer.print(objects[i]);
        }
    }

    public void printLine(Object...objects) {
        print(objects);
        writer.println();
    }

    public void close() {
        writer.close();
    }

}

class Prime {
    // returns a list of n + 1 boolean, 0 to n - 1.
    // ith value true means i is prime, false means i is not a prime.
    public static boolean[] GetIsPrimeList(int n) {
        boolean[] res = new boolean[n + 1];
        for (int i = 0; i < res.length; ++i) {
            res[i] = true;
        }
        res[0] = false;
        res[1] = false;
        for (int i = 2; i * i < res.length; ++i) {
            if (res[i] == true) {
                for (int j = i * i; j < res.length; j += i) {
                    res[j] = false;
                }
            }
        }
        return res;
    }

    }
