A number is called almost prime if it has exactly two distinct prime divisors. For example, numbers 6, 18, 24 are almost prime, while 4, 8, 9, 42 are not. Find the amount of almost prime numbers which are between 1 and n, inclusive.

Input

Input contains one integer number n (1 ≤ n ≤ 3000).

Output

Output the amount of almost prime numbers between 1 and n, inclusive.

Examples

Input

10


Output

2


Input

21


Output

8
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
	public static void main(String[] args) throws IOException {
		Task task = new Task();
		task.getData();
		task.solve();
		task.printAnswer();
	}
}

class Task {
	int n;

	StringBuilder answer = new StringBuilder();
	// int answer = 0;

	public void getData() throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		//BufferedReader br = new BufferedReader(new FileReader("input.txt"));

		n = Integer.parseInt(br.readLine());

		br.close();
	}

	public void solve() {
		ArrayList<Integer> primes = Library.firstPrimes(n);
		
		int counter = 0;
		for (int i = 0; i < primes.size(); ++i) {
			for (int j = i + 1; j < primes.size(); ++j) {
				for (int firstPower = primes.get(i); firstPower <= n; firstPower *= primes.get(i)) {
					for (int secondPower = firstPower * primes.get(j); secondPower <= n; secondPower *= primes.get(j)) {
						//answer.append(secondPower + "\n");
						++counter;
					}
				}
			}
		}
		answer.append(counter);
	}

	public void printAnswer() throws IOException {
		System.out.print(answer);
		/*
		BufferedWriter bw = new BufferedWriter(new FileWriter(new
		File("output.txt")));
		bw.append(answer);
		bw.close();
		*/
	}
}

class Pair {
	int first;
	int second;
	
	Pair(int first, int second) {
		this.first = first;
		this.second = second;
	}
}

class Library extends Object {
	public static long binomial(long n, long k) {
		if (k == 0 || n == k) {
			return 1;
		}
		
		return binomial(n - 1, k - 1) + binomial(n - 1, k);
	}
	
	public static ArrayList<ArrayList<Integer>> permutation(int n) {
		ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
		
		if (n == 1) {
			ArrayList<Integer> listToAdd = new ArrayList<Integer>(Arrays.asList(1));
			result.add(listToAdd);
			return result;
		}
		
		ArrayList<ArrayList<Integer>> old = permutation(n - 1);
		
		for (ArrayList<Integer> current : old) {
			for (int position = 0; position < n; ++position) {
				ArrayList<Integer> listToAdd = new ArrayList<Integer>();
				listToAdd.addAll(current.subList(0, position));
				listToAdd.add(n);
				listToAdd.addAll(current.subList(position, current.size()));
				result.add(listToAdd);
			}
		}
		return result;
	}
	
	public static ArrayList<Integer> firstPrimes(int bound) {
		boolean[] isPrime = new boolean[bound + 1];
		Arrays.fill(isPrime, 2, isPrime.length, true);
		for (int i = 2; i <= Math.sqrt(bound); ++i) {
			if (isPrime[i]) {
				for (int j = i * i; j <= bound; j += i) {
					isPrime[j] = false;
				}
			}
		}

		ArrayList<Integer> primes = new ArrayList<Integer>();
		for (int i = 0; i < isPrime.length; ++i) {
			if (isPrime[i]) {
				primes.add(i);
			}
		}
		return primes;
	}
}