The number 105 is quite special - it is odd but still it has eight divisors. Now, your task is this: how many odd numbers with exactly eight positive divisors are there between 1 and N (inclusive)?

Constraints

* N is an integer between 1 and 200 (inclusive).

Input

Input is given from Standard Input in the following format:


N


Output

Print the count.

Examples

Input

105


Output

1


Input

7


Output

0
n=[int(k) for k in raw_input().split(" ")][0]
  
def gen_primes(n):
    """ Generate prime numbers until n
    """
    # Maps composites to primes witnessing their compositeness.
    # This is memory efficient, as the sieve is not "run forward"
    # indefinitely, but only as long as required by the current
    # number being tested.
    #
    D = {}
    Dr={}
    
    # The running integer that's checked for primeness
    q = 2
    while q<=n:
        if q not in D:
            # q is a new prime.
            # Yield it and mark its first multiple that isn't
            # already marked in previous iterations
            #
            Dr[q]=None
            D[q * q] = [q]
        else:
            # q is composite. D[q] is the list of primes that
            # divide it. Since we've reached q, we no longer
            # need it in the map, but we'll mark the next 
            # multiples of its witnesses to prepare for larger
            # numbers
            # 
            for p in D[q]:
                D.setdefault(p + q, []).append(p)
            del D[q]
        q += 1
    return Dr.keys()


def decompprime(n,primesorted):
    r={}
    j=0
    i=0
    while n>1 and i*i<n:
        i=primesorted[j]
        ri=0
        while n%i==0:
            n/=i
            ri+=1
        if ri>0:
            r[i]=ri
        j+=1
    if n>1:
        r[n]=1
    return r


def isqrt(x):
    if x < 0:
        raise ValueError('square root not defined for negative numbers')
    n = int(x)
    if n == 0:
        return 0
    a, b = divmod(n.bit_length(), 2)
    x = 2**(a+b)
    while True:
        y = (x + n//x)//2
        if y >= x:
            return x
        x = y
        
def divisors(dcp):
    nn=len(dcp)
    init={1:[0]*nn}
    dxs=sorted(dcp.keys())
    for kk in range(nn):
        k=dxs[kk]
        ninit={}
        kj=1
        for j in range(dcp[k]+1):
            for jj in init.keys():
                ninit[jj*kj]=init[jj][:]
                ninit[jj*kj][kk]+=j
            kj*=k
        init=ninit
     #   print init
    return init

ps=sorted(gen_primes(201))
res=0
for i in range(1,n+1,2):
    divs=divisors(decompprime(i,ps))
    if len(divs)==8:
       # print i
        res+=1
print res
