import java.io.*;
import java.util.*;

public class E {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	static final int[] PS = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
			43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 };

	int l, r, p;
	List<Integer> goodAL = new ArrayList<>();

	static int[] toIntArray(List<Integer> a) {
		int[] ret = new int[a.size()];
		int i = 0;
		for (Integer x : a) {
			ret[i++] = x;
		}
		return ret;
	}

	void dfs(int x, int i) {
		if (i == PS.length) {
			return;
		}
		dfs(x, i + 1);
		if (x <= r / PS[i]) {
			int next = x * PS[i];
			goodAL.add(next);
			dfs(next, i);
		}
	}

	void solve() throws IOException {
		l = nextInt();
		r = nextInt();
		p = nextInt();
		goodAL.add(1);
		dfs(1, 0);
		int[] good = toIntArray(goodAL);
		Arrays.sort(good);

		int n = good.length;

		int[] dp = new int[n];
		int oo = Integer.MAX_VALUE / 3;
		Arrays.fill(dp, oo);
		dp[0] = 0;
		for (int x = 2; x <= p; x++) {
			for (int i = 0, j = 0; i < n; i++) {
				long needL = (long) good[i] * x;
				if (needL > r) {
					break;
				}
				while (j < n && good[j] < needL) {
					j++;
				}
				if (j == n || good[j] != needL) {
					continue;
				}
				if (dp[i] + x < p) {
					int a = dp[j];
					int b = dp[i] + 1;
					dp[j] = (a <= b) ? a : b;
				}
			}
		}

		int ans = 0;

		for (int i = 0; i < n; i++) {
			if (good[i] >= l && dp[i] != oo) {
				ans++;
			}
		}

		out.println(ans);
	}

	E() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new E();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}

import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Random;
import java.io.Writer;
import java.util.Collection;
import java.util.List;
import java.util.BitSet;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.util.TreeSet;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;

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

class TaskE {
    // 2944730
    int[] primes;
    int[] candidates;
    int numCandidates;
    public void solve(int testNumber, MyScanner in, MyPrintWriter out) {
        int N = (int) 1e9;
        int L = in.nextInt(), R = in.nextInt();
        int p = in.nextInt();
        if(p<3){
            out.println(0);return;
        }
        primes = MathUtils.generatePrimes(p + 1);
        candidates = new int[2944730];
        Arrays.fill(candidates, Integer.MAX_VALUE);
        numCandidates = 0;
        gen(0, 1L, N);
        Arrays.sort(candidates);
        int[] dist = new int[numCandidates];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[0] = 0;// 1
        boolean[] answer = new boolean[numCandidates];
        answer[0] = true;
        for(int n=2;n<=p;n++){
            for (int i = 0, j = 0; i < dist.length; i++)if(dist[i] < p - n && candidates[i] <= N/n){
                int nxt = candidates[i] * n;
                while(candidates[j] != nxt)j++;
                if(dist[j] > dist[i] + 1){
                    dist[j] = dist[i] + 1;
                    answer[j] = true;
                }
            }
        }
        int res = 0;
        for (int i = 0; i < answer.length; i++)if(answer[i] && L <= candidates[i] && candidates[i] <= R)res++;
        out.println(res);
    }

    private void gen(int p, long number, int N) {
        if (p >= primes.length) {
            candidates[numCandidates++] = (int) number;
            return;
        }
        while (number <= N) {
            gen(p + 1, number, N);
            number *= primes[p];
        }
    }
}

class MyScanner {
    private final InputStream in;

    public MyScanner(InputStream in) {
        this.in = in;
    }

    int bufLen;
    int bufPtr;
    byte[] buf = new byte[1024];

    public int read() {
        if (bufLen == -1)
            throw new InputMismatchException();
        if (bufPtr >= bufLen) {
            bufPtr = 0;
            try {
                bufLen = in.read(buf);
            } catch (IOException e) {
                throw new InputMismatchException();
            }
            if (bufLen <= 0)
                return -1;
        }
        return buf[bufPtr++];
    }

    public int nextInt() {
        try {
            int c = read();
            if (c == -1) return c;
            while (c != '-' && (c < '0' || '9' < c)) {
                c = read();
                if (c == -1) return c;
            }
            if (c == '-') return -nextInt();
            int res = 0;
            do {
                res *= 10;
                res += c - '0';
                c = read();
            } while ('0' <= c && c <= '9');
            return res;
        } catch (Exception e) {
            return -1;
        }
    }

    }

class MyPrintWriter {
    PrintWriter out;

    public MyPrintWriter(OutputStream outputStream) {
        out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
    }

    public MyPrintWriter(Writer writer) {
        out = new PrintWriter(writer);
    }

    public void println(Object... os) {
        for (int i = 0; i < os.length - 1; i++) {
            out.print(os[i]);
            out.print(' ');
        }
        out.println(os[os.length - 1]);
    }

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

    }

class MathUtils {

    public static int[] generatePrimes(int upTo) {
        int N = upTo;
        boolean[] isPrime = generatePrimaryTable(N);
        int m = 0;
        for (boolean p : isPrime) if (p) m++;
        int[] res = new int[m];
        m = 0;
        for (int i = 0; i < isPrime.length; i++) {
            if (isPrime[i]) res[m++] = i;
        }
        return res;
    }

    public static boolean[] generatePrimaryTable(int n) {
        boolean[] isPrime = new boolean[n];
        Arrays.fill(isPrime, true);
        if (0 < n) isPrime[0] = false;
        if (1 < n) isPrime[1] = false;
        for (int i = 2; i * i < n; i++) {
            if (isPrime[i]) {
                for (int j = i * i; j < n; j += i)
                    isPrime[j] = false;
            }
        }
        return isPrime;
    }

    }

import java.io.*;
import java.util.*;

public class E {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	static final int[] PS = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
			43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 };

	int l, r, p;
	List<Integer> goodAL = new ArrayList<>();

	static int[] toIntArray(List<Integer> a) {
		int[] ret = new int[a.size()];
		int i = 0;
		for (Integer x : a) {
			ret[i++] = x;
		}
		return ret;
	}

	void dfs(int x, int i) {
		if (i == PS.length) {
			return;
		}
		dfs(x, i + 1);
		if (x <= r / PS[i]) {
			int next = x * PS[i];
			goodAL.add(next);
			dfs(next, i);
		}
	}

	void solve() throws IOException {
		l = nextInt();
		r = nextInt();
		p = nextInt();
		goodAL.add(1);
		dfs(1, 0);
		int[] good = toIntArray(goodAL);
		Arrays.sort(good);

		int n = good.length;

		int[] dp = new int[n];
		int oo = Integer.MAX_VALUE / 3;
		Arrays.fill(dp, oo);
		dp[0] = 0;
		for (int x = 2; x <= p; x++) {
			for (int i = 0, j = 0; i < n; i++) {
				long needL = (long) good[i] * x;
				if (needL > r) {
					break;
				}
				while (j < n && good[j] < needL) {
					j++;
				}
				if (j == n || good[j] != needL) {
					continue;
				}
				if (dp[i] + x < p && dp[j] > dp[i] + 1) {
					dp[j] = dp[i] + 1;
				}
			}
		}

		int ans = 0;

		for (int i = 0; i < n; i++) {
			if (good[i] >= l && dp[i] != oo) {
				ans++;
			}
		}

		out.println(ans);
	}

	E() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new E();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}

import java.io.*;
import java.util.*;

public class E {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	static final int[] PS = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
			43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 };

	int l, r, p;
	List<Integer> goodAL = new ArrayList<>();

	static int[] toIntArray(List<Integer> a) {
		int[] ret = new int[a.size()];
		int i = 0;
		for (Integer x : a) {
			ret[i++] = x;
		}
		return ret;
	}

	void dfs(int x, int i) {
		if (i == PS.length) {
			return;
		}
		dfs(x, i + 1);
		long next = (long) x * PS[i];
		if (next <= r) {
			goodAL.add((int) next);
			dfs((int) next, i);
		}
	}

	void solve() throws IOException {
		l = nextInt();
		r = nextInt();
		p = nextInt();
		goodAL.add(1);
		dfs(1, 0);
		int[] good = toIntArray(goodAL);
		Arrays.sort(good);

		int n = good.length;

		int[] dp = new int[n];
		int oo = Integer.MAX_VALUE / 3;
		Arrays.fill(dp, oo);
		dp[0] = 0;
		for (int x = 2; x <= p; x++) {
			for (int i = 0, j = 0; i < n; i++) {
				long needL = (long) good[i] * x;
				if (needL > r) {
					break;
				}
				while (j < n && good[j] < needL) {
					j++;
				}
				if (j == n || good[j] != needL) {
					continue;
				}
				if (dp[i] + x < p) {
					dp[j] = Math.min(dp[j], dp[i] + 1);
				}
			}
		}

		int ans = 0;

		for (int i = 0; i < n; i++) {
			if (good[i] >= l && dp[i] != oo) {
				ans++;
			}
		}

		out.println(ans);
	}

	E() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new E();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}

import java.io.*;
import java.util.*;

public class E {

	BufferedReader br;
	PrintWriter out;
	StringTokenizer st;
	boolean eof;

	static final int[] PS = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41,
			43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97 };

	int l, r, p;
	List<Integer> goodAL = new ArrayList<>();

	static int[] toIntArray(List<Integer> a) {
		int[] ret = new int[a.size()];
		int i = 0;
		for (Integer x : a) {
			ret[i++] = x;
		}
		return ret;
	}

	void dfs(int x, int i) {
		if (i == PS.length) {
			return;
		}
		dfs(x, i + 1);
		if (x <= r / PS[i]) {
			int next = x * PS[i];
			goodAL.add(next);
			dfs(next, i);
		}
	}

	void solve() throws IOException {
		l = nextInt();
		r = nextInt();
		p = nextInt();
		goodAL.add(1);
		dfs(1, 0);
		int[] good = toIntArray(goodAL);
		Arrays.sort(good);

		int n = good.length;

		int[] dp = new int[n];
		int oo = Integer.MAX_VALUE / 3;
		Arrays.fill(dp, oo);
		dp[0] = 0;
		for (int x = 2; x <= p; x++) {
			for (int i = 0, j = 0; i < n; i++) {
				long needL = (long) good[i] * x;
				if (needL > r) {
					break;
				}
				while (j < n && good[j] < needL) {
					j++;
				}
				if (j == n || good[j] != needL) {
					continue;
				}
				if (dp[i] + x < p) {
					dp[j] = Math.min(dp[j], dp[i] + 1);
				}
			}
		}

		int ans = 0;

		for (int i = 0; i < n; i++) {
			if (good[i] >= l && dp[i] != oo) {
				ans++;
			}
		}

		out.println(ans);
	}

	E() throws IOException {
		br = new BufferedReader(new InputStreamReader(System.in));
		out = new PrintWriter(System.out);
		solve();
		out.close();
	}

	public static void main(String[] args) throws IOException {
		new E();
	}

	String nextToken() {
		while (st == null || !st.hasMoreTokens()) {
			try {
				st = new StringTokenizer(br.readLine());
			} catch (Exception e) {
				eof = true;
				return null;
			}
		}
		return st.nextToken();
	}

	String nextString() {
		try {
			return br.readLine();
		} catch (IOException e) {
			eof = true;
			return null;
		}
	}

	int nextInt() throws IOException {
		return Integer.parseInt(nextToken());
	}

	long nextLong() throws IOException {
		return Long.parseLong(nextToken());
	}

	double nextDouble() throws IOException {
		return Double.parseDouble(nextToken());
	}
}

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;
    }

    }

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());
    }

    }