IT City company developing computer games invented a new way to reward its employees. After a new game release users start buying it actively, and the company tracks the number of sales with precision to each transaction. Every time when the next number of sales is divisible by all numbers from 2 to 10 every developer of this game gets a small bonus.

A game designer Petya knows that the company is just about to release a new game that was partly developed by him. On the basis of his experience he predicts that n people will buy the game during the first month. Now Petya wants to determine how many times he will get the bonus. Help him to know it.


-----Input-----

The only line of the input contains one integer n (1 ≤ n ≤ 10^18) — the prediction on the number of people who will buy the game.


-----Output-----

Output one integer showing how many numbers from 1 to n are divisible by all numbers from 2 to 10.


-----Examples-----
Input
3000

Output
1

Difficulty: EASY

Solutions:
import math
n = int(input())
k = 1
for i in range(7, 11):
	k = k * i // math.gcd(k, i)
print(n // k)


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)

def lcm(a, b):
	return a // gcd(a, b) * b

def main():
	n = int(input())
	m = 1
	for d in range(2, 11):
		m = lcm(d, m)
	res = n // m
	print(res)
main()


n = int(input())
ans = n // 2520
print(str(ans))


n = int(input())
print(n // (8 * 9 * 5 * 7))


n = int(input())
print(n // 2520)


import math
n = int(input())
c = n / 2520
c = int(math.floor(c))
print(c)


def pol(n, k):
	ans = 1
	for i in range(k):
		ans *= (n - i) / (i + 1)
	k = int(ans)
	if abs(k - ans) < 1 / 2:
		return k
	return k + 1
n = int(input())
d = 9 * 8 * 7 * 5
print(int(n / d))


a = int(input())
print(int(a / 2520))


import math
n = int(input())
print(math.floor(n / (8 * 9 * 5 * 7)))


n = int(input())
print(n // (2 * 3 * 2 * 5 * 1 * 7 * 2 * 3))


c = int(input())
print(c // 2520)


n = int(input())
p = n // 2520
print(p)


def test():
	num = -1
	for i in range(10, 3000):
		ok = 1
		for j in range(2, 10):
			if i % j != 0:
				ok = 0
				break
		if ok == 1:
			num = i
			break
	return num
d = test()
n = int(input())
print(n // d)


n = int(input())
menor = 2520
print(n // menor)


a = int(input())
u = 3 * 5 * 7 * 8 * 3
print(a // u)


import sys
input = sys.stdin.readline

def ceil(x):
	if x != int(x):
		x = int(x) + 1
	return x

def factorial(x, m):
	val = 1
	while x > 0:
		val = val * x % m
		x -= 1
	return val

def fact(x):
	val = 1
	while x > 0:
		val *= x
		x -= 1
	return val

def swaparr(arr, a, b):
	temp = arr[a]
	arr[a] = arr[b]
	arr[b] = temp

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def nCr(n, k):
	if k > n:
		return 0
	if k > n - k:
		k = n - k
	res = 1
	for i in range(k):
		res = res * (n - i)
		res = res / (i + 1)
	return int(res)

def upper_bound(a, x, lo=0, hi=None):
	if hi == None:
		hi = len(a)
	while lo < hi:
		mid = (lo + hi) // 2
		if a[mid] < x:
			lo = mid + 1
		else:
			hi = mid
	return lo

def primefs(n):
	primes = {}
	while n % 2 == 0 and n > 0:
		primes[2] = primes.get(2, 0) + 1
		n = n // 2
	for i in range(3, int(n ** 0.5) + 2, 2):
		while n % i == 0 and n > 0:
			primes[i] = primes.get(i, 0) + 1
			n = n // i
	if n > 2:
		primes[n] = primes.get(n, 0) + 1
	return primes

def power(x, y, p):
	res = 1
	x = x % p
	if x == 0:
		return 0
	while y > 0:
		if y & 1 == 1:
			res = res * x % p
		y = y >> 1
		x = x * x % p
	return res

def swap(a, b):
	temp = a
	a = b
	b = temp
	return (a, b)

def find(x, link):
	p = x
	while p != link[p]:
		p = link[p]
	while x != p:
		nex = link[x]
		link[x] = p
		x = nex
	return p

def union(x, y, link, size):
	x = find(x, link)
	y = find(y, link)
	if size[x] < size[y]:
		(x, y) = swap(x, y)
	if x != y:
		size[x] += size[y]
		link[y] = x

def sieve(n):
	prime = [True for i in range(n + 1)]
	(prime[0], prime[1]) = (False, False)
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	return prime
MAXN = int(100000.0 + 5)

def spf_sieve():
	spf[1] = 1
	for i in range(2, MAXN):
		spf[i] = i
	for i in range(4, MAXN, 2):
		spf[i] = 2
	for i in range(3, ceil(MAXN ** 0.5), 2):
		if spf[i] == i:
			for j in range(i * i, MAXN, i):
				if spf[j] == j:
					spf[j] = i
spf = [0 for i in range(MAXN)]

def factoriazation(x):
	res = []
	for i in range(2, int(x ** 0.5) + 1):
		while x % i == 0:
			res.append(i)
			x //= i
	if x != 1:
		res.append(x)
	return res

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

def float_array():
	return list(map(float, input().strip().split()))

def str_array():
	return input().strip().split()
MOD = int(1000000000.0) + 7
CMOD = 998244353
INF = float('inf')
NINF = -float('inf')
from itertools import permutations
import math
from bisect import bisect_left

def lcm(a, b):
	return a * b // gcd(a, b)

def solve():
	mul = lcm(2, lcm(3, lcm(4, lcm(5, lcm(6, lcm(7, lcm(8, lcm(9, 10))))))))
	n = int(input())
	print(n // mul)
for _ in range(1):
	solve()


x = input()
x = int(x)
print(x // 2520)


import math
DIV = 2520
n = int(input())
print(math.floor(n / 2520))


a = 2520
n = int(input())
print(n // a)


from math import ceil
n = int(input())
x = 2520
print(max(int(n / x) - ceil(1 / x) + 1, 0))


n = int(input())
k = n // 2520
print(k)


print(int(input()) // 2520)


a = int(input())
lcm = 2 ** 3 * 3 ** 2 * 5 * 7
print(a // lcm)


from sys import stdin
num = int(stdin.readline())
K = 2520
print(num // K)


n = int(input())
d = 2 * 3 * 2 * 5 * 7 * 2 * 3
print(n // d)


def main():
	print(int(input()) // 2520)
main()


n = int(input())
abcdefghijklmnop = n // 2520
print(abcdefghijklmnop)


nok = 8 * 9 * 5 * 7
print(int(input()) // nok)


x = int(input())
if x < 2520:
	w = 0
else:
	w = int(x / 2520)
print(w)


n = eval(input())
print(int(n // (2 * 4 * 9 * 7 * 5)))


n = int(input())
mod = 2 * 2 * 2 * 3 * 3 * 5 * 7
print(n // mod)


def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def lcm(a, b):
	return a * b // gcd(a, b)
L = 1
for i in range(2, 11):
	L = lcm(L, i)
n = int(input())
print(n // L)


x = int(input())
cont = 0
if x > 5000:
	cont1 = int(x / 2520)
	print(cont1)
else:
	for i in range(1, x + 1, 1):
		if i % 6 == 0 and i % 7 == 0 and (i % 8 == 0) and (i % 9 == 0) and (i % 10 == 0):
			cont = cont + 1
	print(cont)


import math
n = int(input())
li = [x for x in range(2, 11)]
print(math.floor(n / 2520))


s = str(input())
print(int(s) // 2520)


from math import sqrt
n = int(input())
res = int(n / 2520)
print(res)


print((lambda x: x // 2520)(int(input())))


numero = int(input())
contador = int(numero / 2520)
print(contador)


import math
a = 1
for x in range(2, 11):
	a = a * x // math.gcd(a, x)
n = int(input())
print(n // a)


from math import gcd
g = 2
for i in range(3, 11):
	g = g * i // gcd(i, g)
print(int(input()) // g)


x = int(input())
r = x // 2520
print(r)


print(int(input()) // (2 * 3 * 2 * 5 * 7 * 2 * 3))


n = int(input())
sum = 0
if n >= 2520:
	sum += n // 2520
print(sum)


from sys import stdin, stderr

def readInts():
	return map(int, stdin.readline().strip().split())

def print_err(*args, **kwargs):
	print(*args, file=stderr, **kwargs)

def solve(n):
	v = 2 * 3 * 2 * 5 * 7 * 2 * 3
	return n // v

def run():
	(n,) = readInts()
	print(solve(n))
run()


import sys
input = sys.stdin.readline
import bisect
from math import *

def bo(i):
	return ord(i) - ord('a')
n = int(input())
a = [i for i in range(1, 11)]

def lcm(a):
	g = a[0]
	for i in range(1, 10):
		g = g * a[i] // gcd(g, a[i])
	return g
l = lcm(a)
print(n // l)


import math
n = int(input())
answer = n // 2520
print(answer)


t = 2520
print(int(input()) // t)


factor = 2520
n = int(input())
res = n // factor
print(res)


gcd = lambda b, s: b if s == 0 else gcd(s, b % s)
lcm = lambda a, b: a * b // gcd(a, b)

def f(n):
	x = 10
	for i in range(9, 1, -1):
		x = lcm(x, i)
	return n // x
n = int(input())
print(f(n))


import bisect
from itertools import accumulate
import os
import sys
import math
from decimal import *
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))

def input():
	return sys.stdin.readline().rstrip('\r\n')

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def SieveOfEratosthenes(n):
	prime = []
	primes = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if primes[p] == True:
			prime.append(p)
			for i in range(p * p, n + 1, p):
				primes[i] = False
		p += 1
	return prime

def primefactors(n):
	fac = []
	while n % 2 == 0:
		fac.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 2):
		while n % i == 0:
			fac.append(i)
			n = n // i
	if n > 1:
		fac.append(n)
	return sorted(fac)

def factors(n):
	fac = set()
	fac.add(1)
	fac.add(n)
	for i in range(2, int(math.sqrt(n)) + 1):
		if n % i == 0:
			fac.add(i)
			fac.add(n // i)
	return list(fac)

def modInverse(a, m):
	m0 = m
	y = 0
	x = 1
	if m == 1:
		return 0
	while a > 1:
		q = a // m
		t = m
		m = a % m
		a = t
		t = y
		y = x - q * y
		x = t
	if x < 0:
		x = x + m0
	return x
n = int(input())
print(n // 2520)


def main():
	n = int(input())
	ans = n // (2 * 2 * 2 * 3 * 3 * 5 * 7)
	print(ans)
main()


from sys import stdin
n = int(stdin.readline())
result = n // (2 * 3 * 2 * 5 * 7 * 2 * 3)
print(result)


numero = int(input(''))
print(int(numero / 2520))


from functools import reduce
from math import gcd
n = int(input())
lcd = reduce(lambda x, y: x * y // gcd(x, y), list(range(2, 11)))
print(n // lcd)


n = int(input())
p = 2 * 2 * 2 * 3 * 3 * 5 * 7
print(n // p)


N = int(input())
print(int(N / 2520))


n = 2 * 2 * 2 * 3 * 3 * 5 * 7
m = int(input())
print(m // n)


import collections, itertools, fractions, functools, heapq, math, queue, operator

def solve():
	n = int(input())
	lcm = functools.reduce(operator.mul, [2, 3, 2, 5, 1, 7, 2, 3])
	return n // lcm
print(solve())


import sys
n = int(input())
m = 2 * 3 * 2 * 5 * 7 * 2 * 3
print(n // m)


print(int(input()) // (3 * 6 * 5 * 7 * 4))


n = int(input())
s = n // 2520
print(s)


import math, sys
input = sys.stdin.readline

def inp():
	return int(input())
n = inp()
print(int(n / 2520))


def divisible(n):
	return n // 2520
print(divisible(int(input())))


from math import floor
n = int(input())
print(floor(n / 2520))


import sys
import datetime

def main():
	n = int(input())
	print(n // 2520)
main()


import re
import sys
from bisect import bisect, bisect_left, insort, insort_left
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from itertools import accumulate, combinations, combinations_with_replacement, groupby, permutations, product
from math import acos, asin, atan, ceil, cos, degrees, factorial, gcd, hypot, log2, pi, radians, sin, sqrt, tan
from operator import itemgetter, mul
from string import ascii_lowercase, ascii_uppercase, digits

def inp():
	return int(input())

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

def instr():
	s = input()
	return list(s[:len(s)])

def invr():
	return map(int, input().split())

def prime_fact(n):
	limit = int(sqrt(n)) + 1
	res = []
	for i in range(2, limit + 1):
		while n % i == 0:
			res.append(i)
			n //= i
	if n > 1:
		res.append(n)
	return res
n = inp()
i = 1
c = 0
res = n // 2520
print(res)


n = 2520
x = int(input())
print(int(x // n))


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from itertools import *
import bisect
from heapq import *
from math import *
from copy import *
from collections import deque
from collections import Counter as counter
from itertools import combinations as comb
from itertools import permutations as permutate
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
mod = 1000000007

def inp():
	return sys.stdin.readline().rstrip('\r\n')

def out(var):
	sys.stdout.write(str(var))

def lis():
	return list(map(int, inp().split()))

def stringlis():
	return list(map(str, inp().split()))

def sep():
	return map(int, inp().split())

def strsep():
	return map(str, inp().split())

def zerolist(n):
	return [0] * n

def nextline():
	out('\n')

def testcase(t):
	for p in range(t):
		solve()

def printlist(a):
	for p in range(0, len(a)):
		out(str(a[p]) + ' ')

def lcm(a, b):
	return a * b // gcd(a, b)

def power(a, b):
	ans = 1
	while b > 0:
		if b % 2 == 1:
			ans *= a
		a *= a
		b //= 2
	return ans

def ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True

def solve():
	n = int(inp())
	curr = 1
	for i in range(2, 11):
		curr = lcm(curr, i)
	print(n // curr)
testcase(1)


n = int(input())
a = 1
for i in {8, 9, 5, 7}:
	a *= i
print(n // a)


n = int(input())
k = 2 * 2 * 2 * 3 * 3 * 5 * 7
res = n // k
print(res)


def gcd(a, b):
	while True:
		if a == 0:
			return b
		if b == 0:
			return a
		if a > b:
			a %= b
		else:
			b %= a

def lcm(a, b):
	return a // gcd(a, b) * b

def lcm3(a, b, c):
	return lcm(lcm(a, b), c)

def lcm4(a, b, c, d):
	return lcm(lcm(a, b), lcm(d, c))

def lcm5(a, b, c, d, e):
	return lcm(e, lcm(lcm(a, b), lcm(d, c)))
n = int(input())
k = lcm5(lcm(2, 3), lcm(4, 5), lcm(6, 7), lcm(8, 9), 10)
print(n // k)


from math import gcd
n = int(input())
lcm = 5 * 7 * 8 * 9
print(n // lcm)


import math
n = int(input())
lcm = 2520
if n >= lcm:
	print(n // lcm)
else:
	print(0)


n = int(input())
m = int(n / 2520)
print(m)


from math import gcd
n = int(input())
g = 2
for x in range(3, 11):
	g = g * x // gcd(g, x)
print(n // g)


import math
l = [2, 3, 4, 5, 6, 7, 8, 9, 10]
mul = 1
ans = 1
for i in l:
	ans = ans * i // math.gcd(ans, i)
n = int(input())
print(n // ans)


buyers = int(input())
del_number = 2 * 9 * 5 * 4 * 7
print(buyers // del_number)


a = int(input())
w = 2520
c = a % w
if a < w:
	print(0)
else:
	a -= c
	print(a // 2520)


import io
import sys
n = int(sys.stdin.readline().strip())
number = 2 * 2 * 2 * 3 * 3 * 5 * 7
print(int(n / number))


number = input()
number = int(number)
print(int(number / 2520))


import math as mt
import sys, string, bisect
input = sys.stdin.readline
from collections import deque
L = lambda : list(map(int, input().split()))
Ls = lambda : list(input().split())
M = lambda : map(int, input().split())
I = lambda : int(input())
n = I()
print(n // 2520)


def gcd(x, y):
	return x if y == 0 else gcd(y, x % y)
n = int(input())
t = 1
for i in range(1, 11):
	t = t * i // gcd(t, i)
print(n // t)


import math

def choose(n, r):
	return math.factorial(n) // math.factorial(n - r) // math.factorial(r)

def choose2(n, r):
	return math.factorial(n) // math.factorial(n - r)
n = int(input())
test_number = 2 ** 3 * 3 * 3 * 5 * 7
result = n // test_number
print(result)


D = 2 * 2 * 2 * (3 * 3) * 5 * 7
n = int(input())
print(int(n / D))


def f(n):
	fac = 1
	i = 1
	while i < n:
		i += 1
		fac = fac * i
	return fac

def g(n, k):
	return f(n) // f(k) // f(n - k)
n = int(input())
print(n // 9 // 8 // 5 // 7)


n = int(input())
i = 1
mu = 2520
print(n // 2520)


import sys
LI = lambda : list(map(int, sys.stdin.readline().split()))
MI = lambda : map(int, sys.stdin.readline().split())
SI = lambda : sys.stdin.readline().strip('\n')
II = lambda : int(sys.stdin.readline())
print(II() // 2520)


import math

def prime(n):
	ok = True
	for i in range(2, int(math.sqrt(n))):
		if n % i == 0:
			ok = False
			break
	if ok:
		return True
	else:
		return False

def fact(a, b):
	ans = 1
	for i in range(a, b + 1):
		ans *= i
	return str(ans) - 1

def comb(n, c):
	return fact(n) // (fact(n - c) * c)
n = int(input())
print(n // (8 * 7 * 9 * 5))


A = int(input())
print(int(A / 2520))


import sys, math
n = int(input())
print(n // 8 // 9 // 5 // 7)


N = int(input())
x = 2 * 2 * 2 * 3 * 3 * 5 * 7
print(int(N / x))


y = int(input())
x = 2520
print(y // x)


def STR():
	return list(input())

def INT():
	return int(input())

def MAP():
	return map(int, input().split())

def MAP2():
	return map(float, input().split())

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

def STRING():
	return input()
import string
import sys
from heapq import heappop, heappush
from bisect import *
from collections import deque, Counter, defaultdict
from math import *
from itertools import permutations, accumulate
dx = [-1, 1, 0, 0]
dy = [0, 0, 1, -1]
n = INT()
print(n // 2520)


import math
n = int(input())
print(n // (2 * 3 * 4 * 5 * 7 * 3))


import math
n = int(input())
t = 8 * 9 * 5 * 7
print(n // t)


import math
x = int(input())
print(math.floor(x / 2520))


from sys import stdin, stdout
from math import gcd, ceil, sqrt, factorial as f
ii1 = lambda : int(stdin.readline().strip())
is1 = lambda : stdin.readline().strip()
iia = lambda : list(map(int, stdin.readline().strip().split()))
isa = lambda : stdin.readline().strip().split()
mod = 1000000007
n = ii1()
div = 8 * 5 * 9 * 7
print(n // div)


def main():
	n = int(input())
	print(solver(n))

def solver(n):
	return n // 2520
main()


import math

def lcm(x, y):
	return x * y // math.gcd(x, y)
num = 1
for i in range(2, 11):
	num = lcm(num, i)
n = int(input(''))
print(n // num)


import time
n = int(input())
start = time.time()
print(n // 2520)
finish = time.time()


def main():
	a = 8 * 9 * 5 * 7
	n = int(input())
	print(n // a)
main()


def __starting_point():
	n = int(input())
	print(n // (8 * 9 * 5 * 7))
__starting_point()


lcd = 8 * 9 * 5 * 7
print(int(input()) // lcd)


n = int(input())
ans = 0
ans = int(n / 2520)
print(ans, '\n')


x = eval(input())
z = x / 2520
y = int(z)
print(y)


M = 2520
n = int(input())
print(n // M)


a = int(input())
k = 0
s = a // 2520
if a // 2520 > 0:
	k = k + s
print(k)


nofinput = int(input())
factorialten10 = 2520
print(nofinput // factorialten10)


n = int(input())
d = 2520
print(n // d)


b = int(input())
print(b // 2520)


import os, sys, pdb
import time, calendar, datetime
import math, itertools
import operator as op
from functools import reduce

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom
(n,) = list(map(int, input().split()))
print(n // 2520)