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.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public final class Main
{
	static long mod = 998244353l;
	static Map<Long, Long> invk = new HashMap<>();
	static int f[];
	static int fmin = 0;

	public static void main(String[] args) throws IOException
	{
		Scanner in = getScan(args);
		// int tt = in.nextInt();
		// while (tt-- > 0)
		// {
		int n = in.nextInt();
		boolean[] comp = new boolean[n + 1];
		if (n == 1)
		{
			System.out.println(0);
			return;
		}
		int res = 0;
		comp[1] = true;
		comp[2] = false;
		for (int i = 2; i <= n; i++)
		{
			if (!comp[i])
			{
				for (int j = 2; j <= n / i; j++)
				{
					comp[j * i] = true;
				}
			}
		}

		for (int i = 2; i <= n; i++)
		{
			int j = 2;
			int curr = i;
			int nb = 0;
			while (curr != 1)
			{
				if (!comp[j] && curr % j == 0)
				{
					nb++;
					while (curr % j == 0)
					{
						curr = curr / j;
					}
				}
				j++;
			}
			if (nb == 2)
			{
				res++;
			}
		}

		System.out.println(res);
		// }
	}

	public static long gcd(long a, long b, Pair p)
	{
		long x = 1, y = 0, x1 = 0, y1 = 1, a1 = a, b1 = b;

		while (b1 > 0)
		{
			long q = a1 / b1;
			long tmp = x - q * x1;
			x = x1;
			x1 = tmp;
			tmp = y - q * y1;
			y = y1;
			y1 = tmp;
			tmp = a1 - q * b1;
			a1 = b1;
			b1 = tmp;
		}
		p.first = x;
		p.second = y;
		return a1;
	}

	public static class Pair
	{
		public long first;
		public long second;
	}

	public static long gcd(long a, long b)
	{
		if (a == 0 || b == 0)
		{
			return a | b;
		}
		int shift = Long.numberOfTrailingZeros(a | b);
		a = a >> Long.numberOfTrailingZeros(a);
		while (b > 0)
		{
			b = b >> Long.numberOfTrailingZeros(b);
			if (a > b)
			{
				long tmp = a;
				a = b;
				b = tmp;
			}
			b -= a;
		}
		return a << shift;
	}

	public static int find(Subset[] subset, int i)
	{
		if (subset[i].parent != i)
		{
			subset[i].parent = find(subset, subset[i].parent);
		}
		return subset[i].parent;
	}

	public static void union(Subset[] subset, int x, int y)
	{
		int rootx = find(subset, x);
		int rooty = find(subset, y);
		if (subset[rootx].rank < subset[rooty].rank)
		{
			subset[rootx].parent = rooty;
		}
		else if (subset[rootx].rank > subset[rooty].rank)
		{
			subset[rooty].parent = rootx;
		}
		else
		{
			subset[rootx].parent = rooty;
			subset[rooty].rank++;
		}
	}

	static class Subset
	{
		int parent;
		int rank;
	}

	public static long fact(int n)
	{
		if (n <= fmin)
		{
			return f[n];
		}
		long res = f[fmin];
		for (int i = fmin + 1; i <= n; i++)
		{
			res = (res * i) % mod;
			f[i] = (int) res;
		}
		fmin = n;
		return res;
	}

	public static int log2nlz(int bits)
	{
		if (bits == 0) return 0; // or throw exception
		return 31 - Integer.numberOfLeadingZeros(bits);
	}

	static Scanner getScan(String[] args) throws IOException
	{
		if (args.length == 0)
		{
			return new Scanner(System.in);
		}
		else
		{
			return new Scanner(new File(args[0]));
		}
	}

	static BufferedReader getBuffer(String[] args) throws IOException
	{
		if (args.length == 0)
		{
			return new BufferedReader(new InputStreamReader(System.in));
		}
		else
		{
			return new BufferedReader(new FileReader(args[0]));
		}
	}

	public static long binpowMod(long x, long y, long mod)
	{
		long z = 1;
		x = x % mod;
		while (y > 0)
		{
			if (y % 2 == 1)
			{
				z = (z * x) % mod;
				y--;
			}
			else
			{
				x = (x * x) % mod;
				y = y >> 1;
			}
		}
		return z;
	}

	public static long invMod(long x, long mod)
	{
		if (!invk.containsKey(x))
		{
			invk.put(x, binpowMod(x, mod - 2, mod));
		}
		return invk.get(x);
	}

	public static long divMod(long x, long y, long mod)
	{
		x = x % mod;
		y = y % mod;
		return (x * invMod(y, mod)) % mod;
	}
}