from collections import defaultdict, deque, Counter

from heapq import heappush, heappop, heapify

from itertools import permutations, accumulate, combinations, combinations_with_replacement

from math import sqrt, ceil, floor, factorial

from bisect import bisect_left, bisect_right, insort_left, insort_right

from copy import deepcopy

from operator import itemgetter

from functools import reduce

from fractions import gcd

import sys

def input(): return sys.stdin.readline().rstrip()

def I(): return int(eval(input()))

def Is(): return list(map(int, input().split()))

def LI(): return list(map(int, input().split()))

def TI(): return tuple(map(int, input().split()))

def IR(n): return [I() for _ in range(n)]

def LIR(n): return [LI() for _ in range(n)]

def TIR(n): return [TI() for _ in range(n)]

def S(): return eval(input())

def Ss(): return input().split()

def LS(): return list(eval(input()))

def SR(n): return [S() for _ in range(n)]

def SsR(n): return [Ss() for _ in range(n)]

def LSR(n): return [LS() for _ in range(n)]

sys.setrecursionlimit(10**6)

MOD = 10**9+7

INF = 10**18

# ----------------------------------------------------------- #



n = I()

prime = [3, 5, 7, 11, 13, 17, 19]

A = {a**7 for a in prime if a**7<200}

B = {a*b**3 for a, b in permutations(prime, 2) if a*b**3<200}

C = {a*b*c for a, b, c in permutations(prime, 3) if a*b*c<200}

D = A | B | C

ans = 0

for i in range(n+1):

    if i % 2 == 1 and i in D:

        ans += 1

print(ans)

from math import ceil, sqrt



def prime_factorize_tuple(n):

    ret = []

    tmp = n

    for i in range(2, ceil(sqrt(n))):

        if tmp % i == 0:

            count = 0

            while tmp % i == 0:

                count += 1

                tmp //= i

            ret.append((i, count))



    if tmp != 1:

        ret.append((tmp, 1))



    if not ret:

        ret.append([n, 1])  # n = 1



    return ret



n = int(eval(input()))

ans = 0

for i in range(1, n + 1, 2):

    tmp = 1

    for prime, count in prime_factorize_tuple(i):

        tmp *= (count + 1)

    if tmp == 8:

        ans += 1

print(ans)

from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from itertools import (
    permutations,
    accumulate,
    combinations,
    combinations_with_replacement,
)
from math import sqrt, ceil, floor, factorial
from bisect import bisect_left, bisect_right, insort_left, insort_right
from copy import deepcopy
from operator import itemgetter
from functools import reduce
from fractions import gcd
import sys


def input():
    return sys.stdin.readline().rstrip()


def I():
    return int(eval(input()))


def Is():
    return list(map(int, input().split()))


def LI():
    return list(map(int, input().split()))


def TI():
    return tuple(map(int, input().split()))


def IR(n):
    return [I() for _ in range(n)]


def LIR(n):
    return [LI() for _ in range(n)]


def TIR(n):
    return [TI() for _ in range(n)]


def S():
    return eval(input())


def Ss():
    return input().split()


def LS():
    return list(eval(input()))


def SR(n):
    return [S() for _ in range(n)]


def SsR(n):
    return [Ss() for _ in range(n)]


def LSR(n):
    return [LS() for _ in range(n)]


sys.setrecursionlimit(10**6)
MOD = 10**9 + 7
INF = 10**18
# ----------------------------------------------------------- #
n = I()
prime = [3, 5, 7, 11, 13, 17, 19]
A = {a**7 for a in prime if a**7 < 200}
B = {a * b**3 for a, b in permutations(prime, 2) if a * b**3 < 200}
C = {a * b * c for a, b, c in permutations(prime, 3) if a * b * c < 200}
D = A | B | C
ans = 0
for i in range(n + 1):
    if i % 2 == 1 and i in D:
        ans += 1
print(ans)

from math import ceil, sqrt


def prime_factorize_tuple(n):
    ret = []
    tmp = n
    for i in range(2, ceil(sqrt(n))):
        if tmp % i == 0:
            count = 0
            while tmp % i == 0:
                count += 1
                tmp //= i
            ret.append((i, count))
    if tmp != 1:
        ret.append((tmp, 1))
    if not ret:
        ret.append([n, 1])  # n = 1
    return ret


n = int(eval(input()))
ans = 0
for i in range(1, n + 1, 2):
    tmp = 1
    for prime, count in prime_factorize_tuple(i):
        tmp *= count + 1
    if tmp == 8:
        ans += 1
print(ans)

-from collections import defaultdict, deque, Counter -from heapq import heappush, heappop, heapify -from itertools import ( -    permutations, -    accumulate, -    combinations, -    combinations_with_replacement, -) -from math import sqrt, ceil, floor, factorial -from bisect import bisect_left, bisect_right, insort_left, insort_right -from copy import deepcopy -from operator import itemgetter -from functools import reduce -from fractions import gcd -import sys +from math import ceil, sqrt -def input(): -    return sys.stdin.readline().rstrip() +def prime_factorize_tuple(n): +    ret = [] +    tmp = n +    for i in range(2, ceil(sqrt(n))): +        if tmp % i == 0: +            count = 0 +            while tmp % i == 0: +                count += 1 +                tmp //= i +            ret.append((i, count)) +    if tmp != 1: +        ret.append((tmp, 1)) +    if not ret: +        ret.append([n, 1])  # n = 1 +    return ret -def I(): -    return int(eval(input())) - - -def Is(): -    return list(map(int, input().split())) - - -def LI(): -    return list(map(int, input().split())) - - -def TI(): -    return tuple(map(int, input().split())) - - -def IR(n): -    return [I() for _ in range(n)] - - -def LIR(n): -    return [LI() for _ in range(n)] - - -def TIR(n): -    return [TI() for _ in range(n)] - - -def S(): -    return eval(input()) - - -def Ss(): -    return input().split() - - -def LS(): -    return list(eval(input())) - - -def SR(n): -    return [S() for _ in range(n)] - - -def SsR(n): -    return [Ss() for _ in range(n)] - - -def LSR(n): -    return [LS() for _ in range(n)] - - -sys.setrecursionlimit(10**6) -MOD = 10**9 + 7 -INF = 10**18 -n = I() -prime = [3, 5, 7, 11, 13, 17, 19] -A = {a**7 for a in prime if a**7 < 200} -B = {a * b**3 for a, b in permutations(prime, 2) if a * b**3 < 200} -C = {a * b * c for a, b, c in permutations(prime, 3) if a * b * c < 200} -D = A | B | C +n = int(eval(input())) -for i in range(n + 1): -    if i % 2 == 1 and i in D: +for i in range(1, n + 1, 2): +    tmp = 1 +    for prime, count in prime_factorize_tuple(i): +        tmp *= count + 1 +    if tmp == 8: