26_A. Almost Prime_28935
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.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.List;
import java.io.IOException;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.ArrayList;
import java.util.NoSuchElementException;
import java.math.BigInteger;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author Alex
 */
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);
		TaskA solver = new TaskA();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskA {
    public void solve(int testNumber, InputReader in, OutputWriter out) {
        int n = in.readInt();
        int res = 0;
        for (int i = 1; i <= n; i++) if (IntegerUtils.factorize(i).size() == 2) res++;
        out.print(res);
    }
}

class InputReader {
	private InputStream stream;
	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;

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

	public int read() {
		if (numChars == -1)
			throw new InputMismatchException();
		if (curChar >= numChars) {
			curChar = 0;
			try {
				numChars = stream.read(buf);
			} catch (IOException e) {
				throw new InputMismatchException();
			}
			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();
		}
		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 boolean isSpaceChar(int c) {
		if (filter != null)
			return filter.isSpaceChar(c);
		return isWhitespace(c);
	}

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

class OutputWriter {
	private final PrintWriter writer;

	public OutputWriter(OutputStream outputStream) {
		writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
	}
	public void close() {
		writer.close();
	}
	public void print(int i) {
		writer.print(i);
	}
}

class IntegerUtils {
	public static List<Pair<Long, Integer>> factorize(long number) {
		List<Pair<Long, Integer>> result = new ArrayList<Pair<Long, Integer>>();
		for (long i = 2; i * i <= number; i++) {
			if (number % i == 0) {
				int power = 0;
				do {
					power++;
					number /= i;
				} while (number % i == 0);
				result.add(Pair.makePair(i, power));
			}
		}
		if (number != 1)
			result.add(Pair.makePair(number, 1));
		return result;
	}
}
class Pair<U, V> implements Comparable<Pair<U, V>> {
	public final U first;
	public final V second;

	public static<U, V> Pair<U, V> makePair(U first, V second) {
		return new Pair<U, V>(first, second);
	}

	private Pair(U first, V second) {
		this.first = first;
		this.second = second;
	}

	public boolean equals(Object o) {
		if (this == o) return true;
		if (o == null || getClass() != o.getClass()) return false;

		Pair pair = (Pair) o;

		return !(first != null ? !first.equals(pair.first) : pair.first != null) && !(second != null ? !second.equals(pair.second) : pair.second != null);

	}

	public int hashCode() {
		int result = first != null ? first.hashCode() : 0;
		result = 31 * result + (second != null ? second.hashCode() : 0);
		return result;
	}
	public String toString() {
		return "(" + first + "," + second + ")";
	}

	public int compareTo(Pair<U, V> o) {
		int value = ((Comparable<U>)first).compareTo(o.first);
		if (value != 0)
			return value;
		return ((Comparable<V>)second).compareTo(o.second);
	}
}


10
 21
 2998
 19
 856
 1
 77
 40
 2999
 987
 2997
 500
 1429
 3
 4
 1673
 2000
 222
 1500
 1000
 8
 3000
 2
 285
 36
 980
 12
 1393
 1075
 245
 737
 6
 2990
 241
 2608
 1010
 16
 1795
 20
 5
 229
 61
 616
 57
 66
 1784
 435
 488
 469
 1398
 1100
 32
 39
 341
 122
 114
 1544
 869
 259
 97
 802
 1101
 48
 379
 35
 197
 45
 2103
 548
 126
 1330
 0101
 14
 42
 569
 210
 64
 351
 71
 522
 0111
 89
 56
 641
 185
 23
 425
 1111
 143
 170
 337
 158
 24
 846
 1001
 131
 331
 319
 54
 899
 37
 9
 31
 13
 30
 7
 60
 101
 90
 112
 001
 29
 63
 22
 230
 17
 167

2
 8
 1375
 6
 439
 0
 41
 19
 1375
 501
 1374
 266
 706
 0
 0
 808
 958
 125
 732
 508
 1
 1375
 0
 153
 16
 498
 3
 691
 537
 135
 383
 1
 1370
 132
 1216
 512
 5
 864
 7
 0
 128
 31
 323
 30
 34
 860
 233
 261
 249
 693
 549
 12
 18
 187
 67
 61
 757
 445
 142
 53
 416
 550
 23
 203
 15
 107
 21
 1001
 292
 69
 657
 56
 4
 19
 303
 116
 33
 190
 36
 277
 60
 47
 29
 336
 101
 9
 230
 553
 77
 92
 184
 86
 10
 434
 508
 70
 180
 171
 27
 460
 16
 1
 12
 3
 12
 1
 31
 56
 47
 61
 0
 12
 33
 9
 128
 5
 92
