An elephant decided to visit his friend. It turned out that the elephant's house is located at point 0 and his friend's house is located at point x(x > 0) of the coordinate line. In one step the elephant can move 1, 2, 3, 4 or 5 positions forward. Determine, what is the minimum number of steps he need to make in order to get to his friend's house.


-----Input-----

The first line of the input contains an integer x (1 ≤ x ≤ 1 000 000) — The coordinate of the friend's house.


-----Output-----

Print the minimum number of steps that elephant needs to make to get from point 0 to point x.


-----Examples-----
Input
5

Output
1

Input
12

Output
3



-----Note-----

In the first sample the elephant needs to make one step of length 5 to reach the point x.

In the second sample the elephant can get to point x if he moves by 3, 5 and 4. There are other ways to get the optimal answer but the elephant cannot reach x in less than three moves.

Difficulty: EASY

Solutions:
x = int(input())
g = x // 5
if x % 5 > 0:
	g = g + 1
print(g)


n = int(input())
z = n // 5 + (1 if n % 5 else 0)
print(z)


x = int(input())
counter = 0
for i in range(5, 0, -1):
	counter += x // i
	x -= i * (x // i)
	if x == 0:
		break
print(counter)


from sys import stdout
from math import ceil
num = int(input())
stdout.write(str(int(ceil(num / 5))))


x = int(input())
k = 0
while x > 5:
	x -= 5
	k += 1
print(k + 1)


d = int(input())
if not d % 5 == 0:
	print(d // 5 + 1)
else:
	print(d // 5)


pl = int(input())
step = 0
kol = 0
while step != pl:
	if step + 5 < pl:
		step += 5
		kol += 1
	else:
		if pl - step == 0:
			print(kol)
		else:
			print(kol + 1)
		break


x = int(input())
s = 0
moves = 0
while True:
	if moves + 5 <= x:
		moves += 5
		s += 1
		continue
	elif moves + 4 <= x:
		moves += 4
		s += 1
		continue
	elif moves + 3 <= x:
		moves += 3
		s += 1
		continue
	elif moves + 2 <= x:
		moves += 2
		s += 1
		continue
	elif moves + 1 <= x:
		moves += 1
		s += 1
		continue
	if moves == x:
		break
print(s)


x = int(input(''))
moves = 0
while True:
	if x - 5 > 0:
		moves += 1
		x -= 5
		continue
	elif x == 0:
		break
	else:
		moves += 1
		break
print(moves)


x = int(input(''))
counter = 0
while x > 0:
	counter += 1
	x -= 5
print(counter)


a = int(input())
n = 0
while a > 0:
	if a > 5:
		a -= 5
		n += 1
	else:
		n += 1
		a = 0
print(n)


jarak = int(input())
step = 0
i = 0
for i in range(5, 0, -1):
	if jarak % i != 0 and jarak > i:
		step += int(jarak / i)
		jarak = jarak - step * i
	elif jarak % i == 0:
		step += jarak / i
		break
print(int(step))


x = int(input())
a = x / 5
n = x % 5
if x % 5 == 0:
	print(int(a))
else:
	print(int(a + 1))


x = int(input())
c = 0
while x >= 5:
	c += 1
	x -= 5
while x >= 4:
	c += 1
	x -= 4
while x >= 3:
	c += 1
	x -= 3
while x >= 2:
	c += 1
	x -= 2
while x >= 1:
	c += 1
	x -= 1
print(c)


fd = int(input())
if fd % 5 == 0:
	res = int(fd / 5)
else:
	res = int(fd / 5 + 1)
print(res)


n = int(input())
print(-(-n // 5))


num = str(input(''))
a = int(num)
b1 = int(a / 5)
b2 = int(a % 5)
c1 = int(b2 / 4)
c2 = int(b2 % 4)
d1 = int(c2 / 3)
d2 = int(c2 % 3)
e1 = int(d2 / 2)
e2 = int(d2 % 2)
result = int(b1 + c1 + d1 + e1 + e2)
print(result)


x = int(input())
if x > 5:
	z = x // 5
	m = 0
	if x % 5 == 0:
		m = 0
	else:
		m = 1
	print(z + m)
else:
	print(1)


x = int(input())
min = int(x / 5) + int(x % 5 / 4) + int(x % 5 % 4 / 3) + int(x % 5 % 4 % 3 / 2) + int(x % 5 % 4 % 3 % 2 / 1)
print(min)


number = int(input())
count = 0
while number > 0:
	if number - 5 >= 0:
		count += 1
		number -= 5
	elif number - 4 >= 0:
		count += 1
		number -= 4
	elif number - 3 >= 0:
		count += 1
		number -= 3
	elif number - 2 >= 0:
		count += 1
		number -= 2
	elif number - 1 >= 0:
		count += 1
		number -= 1
print(count)


class Main:
	x = int(input())
	steps = 0
	for i in [5, 4, 3, 2, 1]:
		steps += int(x / i)
		x = x % i
	print(steps)
Main()


steps = int(input())
f = 1
o = 0
if steps <= 5:
	print(1)
elif steps % 5 == 0:
	o = steps / 5
	print(int(o))
elif steps > 5 and steps % 5 != 0:
	o = steps / 5 + 1
	print(int(o))


from math import ceil
print(int(ceil(int(input()) / 5)))


n = int(input())
r = 0
for i in range(5, 0, -1):
	if n == 0:
		break
	if n // i >= 0:
		k = n // i
		r += k
		n = n - i * k
print(r)


n = int(input())
s = 0
if n // 5 > 0:
	s += n // 5
	n %= 5
if n // 4 > 0:
	s += n // 4
	n %= 4
if n // 3 > 0:
	s += n // 3
	n %= 3
if n // 2 > 0:
	s += n // 2
	n %= 2
print(n + s)


x = int(input())
if x % 5 == 0:
	print(x // 5)
elif x // 5 > 0:
	print(x // 5 + 1)
else:
	print(1)


n = int(input())
steps = 0
d = 5
l = [n - i if n >= i else i for i in range(1, 6)]
while n > 0:
	d = l.index(min(l))
	n -= d + 1
	l = [n - i if n >= i else i for i in range(1, 6)]
	steps += 1
print(steps)


a = [5, 4, 3, 2, 1]
n = int(input())
c = 0
for i in a:
	c = c + n // i
	n = n % i
print(c)


co = int(input())
if co % 5 == 0:
	t = 0
else:
	t = 1
print(co // 5 + t)


x = int(input())
steps = 0
while x > 0:
	if x >= 5:
		x -= 5
	elif x >= 4:
		x -= 4
	elif x >= 3:
		x -= 3
	elif x >= 2:
		x -= 2
	else:
		x -= 1
	steps += 1
print(steps)


a = input()
print((int(a) + 4) // 5)


n = int(input())
k = 5
i = 0
while n > 0:
	if n - k >= 0:
		n -= k
		i += 1
	else:
		k -= 1
print(i)


n = int(input())
print(n // 5 + min(n % 5, 1))


n = int(input())
ans = 0
while n != 0:
	if n - 5 >= 0:
		n = n - 5
		ans += 1
	elif n - 4 >= 0:
		n = n - 4
		ans += 1
	elif n - 3 >= 0:
		n = n - 3
		ans += 1
	elif n - 2 >= 0:
		n = n - 2
		ans += 1
	elif n - 1 >= 0:
		n = n - 1
		ans += 1
print(ans)


n = int(input())
r = 0
for i in range(5, 0, -1):
	r += n // i
	n %= i
print(r)


x = int(input())
steps = 0
nums = [1, 2, 3, 4, 5]
while x != 0:
	steps += 1
	if x in nums:
		x -= x
	else:
		x -= 5
print(steps)


ans = 0
n = int(input())
k = 0
while True:
	if ans == n:
		break
	else:
		if n - ans >= 5:
			ans += 5
		elif n - ans >= 4:
			ans += 4
		elif n - ans >= 3:
			ans += 3
		elif n - ans >= 2:
			ans += 2
		elif n - ans >= 1:
			ans += 1
		k += 1
print(k)


friend_house = int(input())
steps = friend_house // 5 + (friend_house % 5 != 0)
print(steps)


a = int(input())
o = 0
for i in range(5, 0, -1):
	y = int(a / i)
	a -= y * i
	o += y
print(o)


position = int(input())
start = 0
L = []
for i in range(6):
	L.append(i)
counter = 0
L.sort(reverse=True)
for i in L:
	while position >= i:
		position -= i
		counter += 1
	if position == 0:
		break
print(counter)


x = int(input())
p = x // 5
if x - p * 5 == 0:
	print(p)
else:
	q = (x - p * 5) // 4
	if x - p * 5 - q * 4 == 0:
		print(p + q)
	else:
		r = (x - p * 5 - q * 4) // 3
		if x - p * 5 - q * 4 - r * 3 == 0:
			print(p + q + r)
		else:
			s = (x - p * 5 - q * 4 - r * 3) // 2
			if x - p * 5 - q * 4 - r * 3 - s * 2 == 0:
				print(p + q + r + s)
			else:
				print(p + q + r + s + 1)


x = int(input())
res = int(x / 5)
if x % 5 != 0:
	res += 1
print(res)


n = int(input())
if int(n / 5) < n / 5:
	print(int(n / 5) + 1)
else:
	print(int(n / 5))


try:
	n = int(input())
	if n % 5 == 0:
		steps = n / 5
		print(int(steps))
	else:
		steps = n // 5 + 1
		print(int(steps))
except:
	pass


k = int(input())
if k % 5 == 0:
	print(k // 5)
else:
	print(k // 5 + 1)


n = int(input())
if n % 5 == 0:
	print(n // 5)
elif n % 5 == 1 or n % 5 == 2 or n % 5 == 3 or (n % 5 == 4):
	print(n // 5 + 1)


n = int(input())
cnt = 0
while n != 0:
	if n - 5 >= 0:
		n = n - 5
	elif n - 4 >= 0:
		n = n - 4
	elif n - 3 >= 0:
		n = n - 3
	elif n - 2 >= 0:
		n = n - 2
	else:
		n = n - 1
	cnt = cnt + 1
print(cnt)


n = int(input())
c = 0
i = n
while i > 5:
	c += 1
	i = i - 5
if i <= 5 and i > 0:
	c += 1
print(c)


x = int(input())
ts = 0
if x % 5 == 0:
	ts = int(x / 5)
else:
	ts = int(x / 5) + 1
print(ts)


n = int(input())
steps = [1, 2, 3, 4, 5]

def closest_n(nu):
	res = 0
	for i in steps:
		if i > nu:
			break
		res = i
	return res
count = 0
while n > 0:
	n -= closest_n(n)
	count += 1
print(count)


n = int(input())
if n <= 5:
	print(1)
else:
	cnt = 0
	while n > 5:
		n -= 5
		cnt += 1
	print(cnt + 1)


from sys import stdin
n = int(stdin.readline().strip())
cant = n // 5
if n % 5 != 0:
	cant += 1
print(cant)


s = int(input())
x = s // 5
if s % 5 == 0:
	print(x)
else:
	print(x + 1)


number = int(input())
counter = 0
while number != 0:
	if number >= 5:
		counter += 1
		number -= 5
	else:
		counter += 1
		number -= number
print(counter)


a = int(input())
pas = a / 5
if a % 5 > 0:
	pas += 1
print(int(pas))


x = int(input())
if x % 5 != 0:
	j = x // 5
	print(j + 1)
else:
	print(x // 5)


y = 0
x = int(input())
y += x // 5
if y * 5 == x:
	print(y)
else:
	remainder = x % 5
	if remainder == 1 or 2 or 3 or 4:
		y += 1
	print(y)


location = int(input())
count = 0
while location != 0:
	if location >= 5:
		location -= 5
		count += 1
	elif location >= 4:
		location -= 4
		count += 1
	elif location >= 3:
		location -= 3
		count += 1
	elif location >= 2:
		location -= 2
		count += 1
	elif location >= 1:
		location -= 1
		count += 1
print('%d' % count)


x = int(input())
summation = 0
summation += x // 5
x = x % 5
summation += x // 4
x = x % 4
summation += x // 3
x = x % 3
summation += x // 2
x = x % 2
summation += x // 1
print(summation)


x = int(input())
step = 0
if x >= 5:
	step += x // 5
	x = x % 5
if x >= 4:
	step += x // 4
	x = x % 4
if x >= 3:
	step += x // 3
	x = x % 3
if x >= 2:
	step += x // 2
	x = x % 2
if x >= 1:
	step += x
print(step)


a = int(input())
print(a // 5 + a % 5 // 4 + a % 5 % 4 // 3 + a % 5 % 4 % 3 // 2 + a % 5 % 4 % 3 % 2 // 1)


x = int(input())
count = 0
while x >= 5:
	x -= 5
	count += 1
while x >= 4:
	x -= 4
	count += 1
while x >= 3:
	x -= 5
	count += 1
while x >= 2:
	x -= 5
	count += 1
while x >= 1:
	x -= 5
	count += 1
print(count)


n = int(input())
sum = 0
for i in range(5, 0, -1):
	while n >= i:
		n -= i
		sum += 1
	continue
print(sum)


count = int(input())
count1 = count // 5
count2 = count % 5
if count2 == 0:
	add = 0
else:
	add = 1
print(count1 + add)


x = int(input())
elep = 0
i = 0
while elep < x:
	elep += 5
	i += 1
print(i)


import sys
import math
import bisect

def main():
	n = int(input())
	if n % 5 == 0:
		print(n // 5)
	else:
		print(n // 5 + 1)
main()


import math
x = int(input())
n = math.ceil(x / 5)
print(n)


n = int(input())
res = int(n / 5)
if int(n % 5) == 0:
	print(res)
else:
	print(res + 1)


x = int(input())
ans = 0
if x <= 5:
	ans = 0
else:
	while x > 5:
		x = x - 5
		ans = ans + 1
ans = ans + 1
print(ans)


from math import *

def main():
	x = int(input())
	print(ceil(x / 5))
main()


n = int(input())
output = 0
for i in range(n):
	if n >= 5:
		output += 1
		n = n - 5
	elif n >= 4:
		output += 1
		n = n - 4
	elif n >= 3:
		output += 1
		n = n - 3
	elif n >= 2:
		output += 1
		n = n - 2
	elif n >= 1:
		output += 1
		n = n - 1
print(output)


n = int(input())
l = [5, 4, 3, 2, 1]
i = 0
count = 0
while n != 0:
	if n >= l[i]:
		n -= l[i]
		count += 1
	else:
		i += 1
print(count)


list = [1, 2, 3, 4, 5]
c = 0
p = int(input())
while p:
	for j in range(4, -1, -1):
		if list[j] <= p:
			c += 1
			p -= list[j]
			break
print(c)


n = int(input())
if n >= 5:
	s = int(n / 5)
	if n % 5 == 0:
		print(s)
	else:
		s = s + 1
		print(s)
else:
	print('1')


_input = int(input())
total_step = 0
for counter in range(5, 0, -1):
	if _input != 0:
		if _input >= counter:
			total_step = total_step + _input // counter
			_input = _input % counter
print(total_step)


x = int(input())
counter = 0
while x != 0:
	if x // 5 >= 1:
		counter += x // 5
		x -= x // 5 * 5
	if x // 4 >= 1:
		counter += x // 4
		x -= x // 4 * 4
	if x // 3 >= 1:
		counter += x // 3
		x -= x // 3 * 3
	if x // 2 >= 1:
		counter += x // 2
		x -= x // 2 * 2
	if x == 1:
		counter += 1
		x -= 1
print(counter)


a = int(input())
ans = 0
ans += a // 5
if a % 5 != 0:
	ans += a % 5 // 4
	if a % 5 % 4 != 0:
		ans += a % 5 % 4 // 3
		if a % 5 % 4 % 3 != 0:
			ans += a % 5 % 4 % 3 // 2
			if a % 5 % 4 % 3 % 2 != 0:
				ans += 1
print(ans)


import math
_ = int(input())
print(math.ceil(_ / 5))


n = int(input())
a = [1, 2, 3, 4, 5]
if n > 5:
	p = n // 5
	q = n % 5
	if q in a:
		p += 1
	print(p)
elif n <= 5:
	print(1)


from math import ceil
n = int(input())
d = n / 5
print(ceil(d))


n = int(input())
count = 0
while n % 5 != 0:
	if n % 5 == 1:
		n = n - 1
	elif n % 5 == 2:
		n = n - 2
	elif n % 5 == 3:
		n = n - 3
	elif n % 5 == 4:
		n = n - 4
	count = count + 1
while n % 5 == 0:
	if n == 0:
		break
	n = n - 5
	count = count + 1
print(count)


x = int(input())
k = 0
k += x // 5
x -= x // 5 * 5
k += x // 4
x -= x // 4 * 4
k += x // 3
x -= x // 3 * 3
k += x // 2
x -= x // 2 * 2
k += x
print(k)


x = int(input())
ans = 0
if x // 5 >= 1:
	if x % 5 == 0:
		ans = x // 5
	else:
		ans = x // 5 + 1
elif x // 4 >= 1:
	if x % 4 == 0:
		ans = x // 4
	else:
		ans = x // 4 + 1
elif x // 3 >= 1:
	if x % 3 == 0:
		ans = x // 3
	else:
		ans = x // 3 + 1
elif x // 2 >= 1:
	if x % 2 == 0:
		ans = x // 2
	else:
		ans = x // 2 + 1
else:
	ans = 1
print(ans)


n = int(input())
(x, y) = divmod(n, 5)
if n <= 5:
	print(1)
elif y == 0:
	print(x)
else:
	print(x + 1)


a = int(input())
count = 0
while a >= 5:
	a = a - 5
	count = count + 1
while a >= 4:
	a = a - 4
	count = count + 1
while a >= 3:
	a = a - 3
	count = count + 1
while a >= 2:
	a = a - 2
	count = count + 1
while a >= 1:
	a = a - 1
	count = count + 1
print(count)


pos = int(input())
steps = 0
steps += pos // 5
if pos % 5 != 0:
	steps += 1
print(steps)


n = int(input())
sum = 0
for i in range(5, 1, -1):
	sum += n // i
	n = n - n // i * i
print(sum + n % 2)


n = int(input())
i = 0
if n % 5 == 0:
	print(n // 5)
else:
	print(n // 5 + 1)


n = int(input())
nums = [5, 4, 3, 2, 1]
ans = 0
for i in nums:
	ans += n // i
	if n % i == 0:
		break
	n = n % i
print(ans)


distance = int(input())
steps = distance // 5
if distance % 5 != 0:
	steps += 1
print(steps)


num = int(input())
s = 0
a = num // 5
s += a
temp = num % 5
b = temp // 4
s += b
temp = temp % 4
c = temp // 3
s += c
temp = temp % 3
d = temp // 2
s += d
temp = temp % 2
e = temp // 1
s += e
print(s)


x = int(input(''))
inRound = 0
fifthRounds = 1
temp = 0
for i in range(x):
	inRound += 1
	if inRound == temp + 6:
		temp = inRound - 1
		fifthRounds += 1
print(fifthRounds)


dis_remaining = int(input())
num_of_steps = int(0)
for i in range(5, 0, -1):
	num_of_steps += dis_remaining // i
	dis_remaining = dis_remaining % i
print(num_of_steps)


dis = int(input())
m = dis // 5
m1 = dis % 5
if m1 != 0:
	m += 1
print(m)


num = int(input(''))
list1 = [5, 4, 3, 2, 1]
cnt = 0
for i in list1:
	temp = num // i
	num -= i * temp
	cnt += temp
print(cnt)


friend = int(input())
if friend % 5 == 0:
	result = int(friend / 5)
else:
	result = int(friend / 5) + 1
print(result)


x = int(input())
s = 0
while x > 5:
	x = x - 5
	s += 1
s += 1
print(s)


import math
x = int(input())
num = math.ceil(x / 5)
print(num)


n = int(input())
if n % 5 == 0:
	count = n // 5
	print(count)
else:
	count = n // 5 + 1
	print(count)


steps = input()
steps = int(steps)
a = steps // 5
if steps % 5 == 0:
	print(a)
else:
	print(a + 1)


n = int(input())
steps = n // 5
if n % 5 != 0:
	steps = steps + 1
print(steps)


steps = int(input())
if steps < 5 and steps != 0:
	print(1)
elif steps % 5 == 0:
	output = steps // 5
	print(output)
elif steps > 5 and steps % 5 != 0:
	output = steps // 5 + 1
	print(output)
elif steps == 0:
	print(0)


x = int(input())
i = 0
while x >= 5:
	x = x - 5
	i = i + 1
if x > 0:
	i = i + 1
while x <= -5:
	x = x + 5
	i = i + 1
if x < 0:
	i = i + 1
print(i)


x = int(input())
chances = 0
while x > 0:
	for i in range(5, 0, -1):
		while x > 0:
			x = x - i
			chances += 1
print(chances)


n = int(input())
c = 0
while n >= 5:
	n = n - 5
	c += 1
while n >= 4:
	n = n - 4
	c += 1
while n >= 3:
	n = n - 3
	c += 1
while n >= 2:
	n = n - 2
	c += 1
while n >= 1:
	n = n - 1
	c += 1
print(c)


n = int(input())
steps = 0
while n >= 5:
	steps += 1
	n -= 5
while n >= 4:
	steps += 1
	n -= 4
while n >= 3:
	steps += 1
	n -= 3
while n >= 2:
	steps += 1
	n -= 2
while n >= 1:
	steps += 1
	n -= 1
print(steps)


n = int(input())
if n <= 5:
	print('1')
elif n % 5 == 0:
	print(n // 5)
else:
	t = n // 5
	print(t + 1)


n = int(input())
s = 0
n1 = 5
while n != 0:
	s += n // n1
	n = n % n1
	n1 -= 1
print(s)


def main():
	x = int(input())
	if x % 5 == 0:
		print(int(x / 5))
	else:
		print(int(x / 5 + 1))
main()


x = int(input())
mid = int(x / 5)
if x % 5 == 0:
	print(int(x / 5))
else:
	print(int(x / 5) + 1)


def Steps_2():
	X = int(input())
	Step_List = [5, 4, 3, 2, 1]
	cnt = 0
	i = 0
	while X > 0:
		cnt += X // Step_List[i]
		X = X % Step_List[i]
		i += 1
	print(cnt)
Steps_2()


x = int(input())
ls = [5, 4, 3, 2, 1]
co = 0
while x != 0:
	for i in ls:
		if x >= i:
			x = x - i
			co += 1
			break
print(co)


def get_values():
	movements = [m for m in range(1, 6)]
	x = int(input())
	counter = 0
	while x >= 5:
		x -= 5
		counter += 1
	if x > 0 and x < 5:
		counter += 1
	return print(counter)
get_values()


import math
n = int(input())
c = 0
for i in range(5, 0, -1):
	temp = n // i
	n -= i * temp
	c += temp
print(c)


n = int(input())
ret = n // 5 + (n % 5 != 0)
print(ret)


import math
n = int(input())
print(math.floor((n + 4) / 5))


a = int(input())
if a % 5 == 0:
	r1 = a / 5
	print(int(r1))
else:
	r1 = a // 5 + 1
	print(int(r1))


s = 0
n = int(input())
for i in range(5, 0, -1):
	s += n // i
	n = n % i
print(s)


import bisect
n = int(input())
l = [1, 2, 3, 4, 5]
c = 0
while 1:
	if n == 0:
		break
	else:
		v = bisect.bisect(l, n)
		c = c + n // l[v - 1]
		n = n % l[v - 1]
print(c)


n = int(input())
count = 0
for i in range(0, 5):
	if n > 0:
		temp = int(n / (5 - i))
		n = n - (5 - i) * temp
		count = count + temp
	else:
		break
print(count)


x = int(input())
movement = x // 5
if x % 5 != 0:
	movement += 1
print(movement)


def moves(ele):
	deno = [1, 2, 3, 4, 5]
	i = 4
	cnt = 0
	while i >= 0:
		while ele >= deno[i]:
			ele = ele - deno[i]
			cnt += 1
		i -= 1
	return cnt
n = int(input())
numb = moves(n)
print(numb)


n = int(input())
s = n % 5
ans = n // 5
if s != 0:
	ans = ans + 1
print(ans)


s = input()
s = int(s)
a = s // 5
b = (s - 5 * a) // 4
c = (s - 5 * a - 4 * b) // 3
d = (s - 5 * a - 4 * b - 3 * c) // 2
e = (s - 5 * a - 4 * b - 3 * c - 2 * d) // 1
print(a + b + c + d + e)


x = int(input())
t = 0
for i in range(5, 0, -1):
	d = x // i
	t = t + d
	if d != 0:
		x -= d * i
print(t)


def minimumMove(position):
	minimum = 0
	while position != 0:
		if position >= 5:
			position = position - 5
		elif position >= 4:
			position = position - 4
		elif position >= 3:
			position = position - 3
		elif position >= 2:
			position = position - 2
		else:
			position = position - 1
		minimum = minimum + 1
	return minimum
position = int(input())
print(minimumMove(position))


x = int(input())
if x >= 6:
	if x / 5 != x // 5:
		i = x // 5 + 1
	else:
		i = x // 5
	print(str(i))
else:
	print('1')


t = int(input())
count = 0
if t >= 5:
	n = t // 5
	t = t % 5
	count = count + n
if t >= 4:
	n = t // 4
	t = t % 4
	count = count + n
if t >= 3:
	n = t // 3
	t = t % 3
	count = count + n
if t >= 2:
	n = t // 2
	t = t % 2
	count = count + n
if t >= 1:
	n = t // 1
	t = t % 1
	count = count + n
print(count)


n = int(input())
five = n // 5
n -= five * 5
if n > 0:
	five += n // 4
	n -= n // 4 * 4
if n > 0:
	five += n // 3
	n -= n // 3 * 3
if n > 0:
	five += n // 2
	n -= n // 2 * 2
if n > 0:
	five += n // 1
	n -= n // 1 * 1
print(five)


n = int(input())
if n <= 5:
	print(1)
else:
	p = n // 5
	if n % 5 == 0:
		print(p)
	else:
		print(p + 1)


p = int(input())
for i in range(5):
	if p % 5 != 0:
		p = p + 1
	else:
		break
print(int(p / 5))


a = int(input())
print(a // 5 + int(bool(a % 5)))


a = int(input())
li = [5, 4, 3, 2, 1]
br = 0
for i in li:
	br = br + a // i
	a = a % i
print(br)


n = int(input())
arr = [5, 4, 3, 2, 1]
i = 0
ans = 0
while i < 5 and n > 0:
	ans += n // arr[i]
	n -= n // arr[i] * arr[i]
	i += 1
print(ans)


n = int(input())
count = 0
if n > 5:
	while n > 5:
		n -= 5
		count += 1
		if n <= 5:
			count += 1
			break
elif n <= 5:
	count += 1
print(count)


friend_x = int(input())
distances = friend_x / 5
final_result = distances
if friend_x % 5 != 0:
	final_result = final_result + 1
print(int(final_result))


n = int(input())
count = 0
count += n // 5
n -= 5 * (n // 5)
count += n // 4
n -= 4 * (n // 4)
count += n // 3
n -= 3 * (n // 3)
count += n // 2
n -= 2 * (n // 2)
count += n // 1
print(count)


import math

def main(data):
	return math.ceil(data / 5)
n = int(input())
print(main(n))


n = int(input())
steps = 0
while n >= 5:
	n -= 5
	steps += 1
if n:
	print(steps + 1)
else:
	print(steps)


import math
input1 = int(input())
print(math.ceil(input1 / 5))


n = int(input())
if n > 5 and n % 5 != 0:
	x = n / 5
	print(int(x + 1))
elif n % 5 == 0:
	print(int(n / 5))
else:
	print('1')


n = int(input())
c = 0
while n > 0:
	if n > 5:
		n = n - 5
		c += 1
	else:
		c += 1
		n = 0
print(c)


x = int(input())
count = 0
if x >= 5:
	count = x // 5
	x = x % 5
if x > 0:
	count += 1
print(count)


a = int(input())
m = a // 5
b = a % 5
n = b // 4
c = b % 4
l = c // 3
d = c % 3
p = d // 2
e = d % 2
print(m + n + l + p + e)


n = int(input())
l = n // 5
if n % 5 != 0:
	l = l + 1
print(l)


n = int(input())
arr = [5, 4, 3, 2, 1]
sum = 0
while n > 0:
	n = n - arr[0]
	sum = sum + 1
print(sum)


x = int(input())
n = x // 5
if x % 5 == 0:
	print(n)
elif x % 5 != 0:
	n = n + 1
	print(n)


x = int(input())
sum = 0
r = 0
a = x // 5
sum = sum + a
r = x % 5
if r == 0:
	print(sum)
else:
	print(sum + 1)


n = int(input())
if n % 5 == 0:
	ans = n // 5
else:
	ans = n // 5 + 1
print(ans)


n = int(input())
t1 = n // 5
if t1 > 0:
	n = n % 5
t2 = n // 4
if t2 > 0:
	n = n % 4
t3 = n // 3
if t3 > 0:
	n = n % 3
t4 = n // 2
if t4 > 0:
	n = n % 2
t5 = n // 1
print(t1 + t2 + t3 + t4 + t5)


import math
a = float(input())
print(math.ceil(a / 5))


(x, res, steps, i, ost) = (int(input()), 0, [i + 1 for i in range(5)], 4, 0)
while x:
	if x >= steps[i]:
		ost = x // steps[i]
		res += ost
		x -= steps[i] * ost
	i -= 1
print(res)


import math
n = int(input())
if n > 5 and n % 5 != 0:
	count = math.floor(n / 5) + 1
elif n > 5 and n % 5 == 0:
	count = int(n / 5)
else:
	count = 1
print(count)


def ele(x):
	if x == 0:
		return 0
	else:
		return 1
n = int(input())
bu = n // 5 + ele(n % 5)
print(bu)


x = int(input())

def slon(x):
	if x % 5 == 0:
		return x // 5
	return x // 5 + 1
print(slon(x))


from sys import stdin, stdout
n = stdin.readline()
n = int(n)
answer = round(n / 5)
if n - answer * 5 > 0:
	answer += 1
stdout.write(str(answer))


import sys
n = int(sys.stdin.readline().strip())
move5 = n // 5
if n % 5 == 0:
	print(move5)
else:
	print(move5 + 1)


def read() -> int:
	return int(input())

def read_list() -> list:
	return list(map(int, input().split()))
x = read()
s = 0
while x > 0:
	if x >= 5:
		x -= 5
	elif x >= 4:
		x -= 4
	elif x >= 3:
		x -= 3
	elif x >= 2:
		x -= 2
	elif x >= 1:
		x -= 1
	s += 1
print(s)


import math
n = int(input())
a = [0] * 5
a[0] = math.ceil(n / 5)
a[1] = math.ceil(n / 4)
a[2] = math.ceil(n / 3)
a[3] = math.ceil(n / 2)
a[4] = math.ceil(n / 1)
a.sort()
print(a[0])


x = int(input())
c = 0
while x > 5:
	x = x - 5
	c += 1
c += 1
print(c)


x = int(input())
sum = 0
sum += x // 5
if x % 5 != 0:
	sum += 1
print(sum)


n = int(input())
n1 = n // 5
n2 = n % 5 // 4
n3 = n % 5 % 4 // 3
n4 = n % 5 % 4 % 3 // 2
n5 = n % 5 % 4 % 3 % 2 // 1
print(n1 + n2 + n3 + n4 + n5)


n = int(input())
if n < 6:
	cnt = 1
elif n % 5 == 0:
	cnt = int(n / 5)
else:
	cnt = int(n / 5) + 1
print(cnt)


x = int(input())
k = 0
for i in range(5):
	k += x // (5 - i)
	x = x % (5 - i)
	if x == 0:
		break
print(k)


n = int(input())
num_of_step = int(0)
dis_remaining = n
num_of_step += n // 5
dis_remaining = n % 5
num_of_step += dis_remaining // 4
dis_remaining = dis_remaining % 4
num_of_step += dis_remaining // 3
dis_remaining = dis_remaining % 3
num_of_step += dis_remaining // 2
dis_remaining = dis_remaining % 2
num_of_step += dis_remaining // 1
print(num_of_step)


temp = [1, 2, 3, 4, 5]
n = int(input())
count = 0
while n > 0:
	if n in temp:
		count += 1
		break
	else:
		n -= temp[-1]
		count += 1
print(count)


n = int(input())
steps = 0
if n <= 5:
	print('1')
else:
	five = int(n / 5)
	steps += five
	n = n - five * 5
	if n != 0:
		steps += 1
	print(steps)


from math import ceil
x = int(input())
result = ceil(x / 5)
print(result)


n = int(input())
t = n
c = 0
while t > 0:
	if t % 5 >= 0:
		c = c + 1
		t = t - 5
	elif t % 4 >= 0:
		c = c + 1
		t = t - 4
	elif t % 3 >= 0:
		c = c + 1
		t = t - 3
	elif t % 2 >= 0:
		c = c + 1
		t = t - 2
	elif t % 1 >= 0:
		c = c + 1
		t = t - 1
print(c)


x = int(input())
s = 0
count = 0
while s != x:
	if s + 5 <= x:
		s += 5
		count += 1
	elif s + 4 <= x:
		s += 4
		count += 1
	elif s + 3 <= x:
		s += 3
		count += 1
	elif s + 2 <= x:
		s += 2
		count += 1
	else:
		s += 1
		count += 1
print(count)


n = int(input())
hasil = 0
while n > 0:
	hasil += 1
	n -= 5
print(hasil)


x = int(input())
n = 0
n += x // 5
x -= 5 * (x // 5)
n += x // 4
x -= 4 * (x // 4)
n += x // 3
x -= 3 * (x // 3)
n += x // 2
x -= 2 * (x // 2)
n += x
print(n)


n = int(input())
count = 0
while True:
	if n >= 5:
		n = n - 5
		count += 1
	elif n == 4:
		n = n - 4
		count += 1
	elif n == 3:
		n -= 3
		count += 1
	elif n == 2:
		n -= 2
		count += 1
	elif n == 1:
		n -= 1
		count += 1
	else:
		pass
	if n == 0:
		print(count)
		break


import math
n = int(input())
ans = 0
if n < 5:
	ans = 1
else:
	ans = math.ceil(n / 5)
print(ans)


import math
x = int(input())
a = x / 5
print(math.ceil(a))


x = int(input())
a = b = c = d = e = 0
while x >= 5:
	x = x - 5
	a = a + 1
while x >= 4:
	x = x - 4
	b = b + 1
while x >= 3:
	x = x - 3
	c = c + 1
while x >= 2:
	x = x - 2
	d = d + 1
while x >= 1:
	x = x - 1
	e = e + 1
print(a + b + c + d + e)


a = int(input())
q = 0
q += a // 5
if a % 5 != 0:
	q += 1
print(q)


n = int(input())
sum = 0
i = 0
m = 1
if n == 1:
	print(1)
else:
	while m < n:
		sum = sum + 1
		i = i + 1
		m = i * 5
	print(sum)


n = int(input())
l = [5, 4, 3, 2, 1]
c = 0
for i in l:
	if n >= i:
		c += n // i
		n = n % i
print(c)


x = int(input())
steps = 0
for i in range(5, 0, -1):
	if x // i > 0:
		steps = steps + x // i
		x = x % i
print(steps)


def min_c(v):
	if v % 5 == 0:
		return v // 5
	else:
		return v // 5 + 1
v = int(input())
print(min_c(v))


x = int(input(''))
if x > 5:
	y = int(x / 5)
	z = x / 5
	if y == z:
		print(y)
	else:
		print(y + 1)
if x <= 5:
	print(1)


n = int(input())
mx_step = 5
act_p = 1
while True:
	a = n - mx_step
	if a == 0:
		break
	elif a < 0:
		mx_step -= 1
	else:
		act_p += 1
		n = a
print(act_p)


x = int(input())
i = 5
while i >= 1:
	if x % i == 0:
		print(int(x / i))
		break
	elif x % i < 5:
		print(int(x / i) + 1)
		break
	else:
		i = i - 1


def passos(num):
	steps = 0
	while num != 0:
		if num >= 5:
			num -= 5
			steps += 1
		elif num >= 4:
			num -= 4
			steps += 1
		elif num >= 3:
			num -= 3
			steps += 1
		elif num >= 2:
			num -= 2
			steps += 1
		elif num >= 1:
			num -= 1
			steps += 1
	return steps
casa_pos = int(input())
print(passos(casa_pos))


x = int(input())
step = 0
path = 0
while x > path:
	step = step + 1
	path = path + 5
print(step)


a = int(input())
counter = 0
counter += int(a / 5)
a %= 5
counter += int(a / 4)
a %= 4
counter += int(a / 3)
a %= 3
counter += int(a / 2)
a %= 2
counter += a
print(counter)


n = int(input())
r = 0
while n >= 5:
	r += int(n / 5)
	n = n % 5
if n != 0:
	r += 1
print(r)


x = int(input())
move = 0
count = 0
if x % 5 == 0:
	count = x // 5
else:
	count = x // 5
	if x % 5 < 5:
		count += 1
print(count)


d = int(input())
s = [4, 3, 2, 1]
n = 0
while d >= 5:
	d -= 5
	n += 1
for i in s:
	while d % i == 0 and d > 0:
		d -= i
		n += 1
print(n)


x = int(input())
print(x // 5 + int(x % 5 > 0))


loc = int(input())
if loc % 5 == 0:
	print(loc // 5)
else:
	print(loc // 5 + 1)


n = int(input())
steps = (5, 4, 3, 2, 1)
count = 0
while n > 0:
	for step in steps:
		if n >= step:
			count = count + 1
			n = n - step
			break
print(count)


n = int(input())
a = 0
a = int(n / 5)
if n % 5 != 0:
	a += 1
print(a)


n = int(input())
i = 5
cnt = 0
while True:
	if n - i == 0:
		cnt += 1
		break
	elif i > n:
		i -= 1
	else:
		n -= i
		cnt += 1
print(cnt)


x = int(input())
steps = 1
while x > 5:
	x = x - 5
	steps = steps + 1
print(steps)


i = 0
a = int(input())
if a == 1 or a == 2 or a == 3 or (a == 4) or (a == 5):
	print('1')
else:
	while a > 0:
		i = i + 1
		a = a - 5
		if a == 1 or a == 2 or a == 3 or (a == 4) or (a == 5):
			i = i + 1
	print(i - 1)


n = int(input())
k = 0
while n > 0:
	n -= 5
	k += 1
print(k)


def answer():
	a = int(input())
	ans = int(a / 5) + 1 * (a % 5 != 0)
	return ans
print(answer())


n = int(input())
moves = 0
i = 5
while n != 0:
	moves = moves + n // i
	n = n - i * (n // i)
	i = i - 1
print(moves)


x = int(input())
steps = 0
c5 = 0
c4 = 0
c3 = 0
c2 = 0
c1 = 0
while x > 0:
	if x >= 5:
		x -= 5
		steps += 1
		c5 += 1
	elif x >= 4:
		x -= 4
		steps += 1
		c4 += 1
	elif x >= 3:
		x -= 3
		steps += 1
		c3 += 1
	elif x >= 2:
		x -= 2
		steps += 1
		c2 += 1
	else:
		x -= 1
		steps += 1
		c1 += 1
print(steps)


num = int(input())
cost = 0
cost = cost + num // 5
num = num % 5
cost = cost + num // 4
num = num % 4
cost = cost + num // 3
num = num % 3
cost = cost + num // 2
num = num % 2
cost = cost + num // 1
num = num % 1
print(cost)


x = 0
friend = int(input())
steps = 0
index = 5
while index > 0:
	if friend >= index:
		steps += friend // index
		friend = friend % index
	index -= 1
print(steps)


n = int(input())
l = [5, 4, 3, 2, 1]
s1 = 0
c = 0
x = n % 5
for i in l:
	if x == 0:
		c = n // 5
	else:
		c = n // 5 + 1
print(c)


a = int(input())
s = 0
count = 0
while s < a:
	b = a - s
	if b >= 5:
		s += 5
		count += 1
	elif b == 4:
		s += 4
		count += 1
	elif b == 3:
		s += 3
		count += 1
	elif b == 2:
		s += 2
		count += 1
	elif b == 1:
		s += 1
		count += 1
print(count)


a = int(input())
j = 0
for i in range(5, 1, -1):
	while a > 0:
		a = a - i
		j = j + 1
	break
print(j)


num = int(input())
if num >= 0 and num < 5:
	print(1)
elif num % 5 == 0:
	print(num // 5)
else:
	print(num // 5 + 1)


x = int(input())
ans = x // 5
if x % 5 > 0:
	ans += 1
print(ans)


a = int(input())
l = [5, 4, 3, 2, 1]
t = a
count = 0
i = 0
while t != 0:
	if t >= l[i]:
		count += t // l[i]
		t = t % l[i]
		i += 1
	else:
		i += 1
print(count)


n = int(input())
sums = 0
for i in range(5, 0, -1):
	sums += n // i
	n = n % i
print(sums)


x = int(input())
res = (x + 4) // 5
print(res)


n = int(input())
sum = n // 5
if n % 5 == 0:
	print(sum)
else:
	print(sum + 1)


import math
n = int(input())
k = math.ceil(n / 5.0)
print(int(k))


def steps(n):
	c = 0
	for x in range(5, 0, -1):
		new = n - n // x * x
		if n != new:
			c += n // x
		n = new
	return c
n = int(input())
print(steps(n))


SPEEDS = [5, 4, 3, 2, 1]
n = int(input())
count = 0
for i in SPEEDS:
	count += n // i
	n %= i
print(count)


y = int(input())

def elephant(x):
	step_count = 0
	while x >= 0:
		if x <= 5:
			step_count += 1
			return print(step_count)
		elif x > 5:
			x = x - 5
			step_count += 1
	return print(step_count)
elephant(y)


m = int(input())
print((m - 1) // 5 + 1)


loc = int(input())
steps = 5
cntr = 0
while loc != 0:
	if loc - steps > -1:
		cntr += 1
		loc -= steps
	else:
		steps -= 1
print(cntr)


import math
a = int(input())
if a % 5 == 0:
	print(int(a / 5))
else:
	print(int(math.ceil(a / 5)))


try:
	while True:
		x = int(input())
		print((x + 4) // 5)
except EOFError:
	pass


n = int(input())
c = 1
while n > 5:
	c += 1
	n -= 5
print(c)


n = int(input())
answer = 0
answer += n // 5
n -= n // 5 * 5
answer += n // 4
n -= n // 4 * 4
answer += n // 3
n -= n // 3 * 3
answer += n // 2
n -= n // 2 * 2
answer += n
n -= n
print(answer)


address = input()
address = int(address)
tip = 0
while address > 5:
	address -= 5
	tip += 1
tip += 1
print(tip)


x = int(input())
am = x // 5
if x % 5 != 0:
	am += 1
print(am)


number = int(input())
result = 0
remainder = 0
while True:
	if number >= 5:
		number = number - 5
		result = result + 1
	elif number >= 4:
		number = number - 4
		result = result + 1
	elif number >= 3:
		number = number - 3
		result = result + 1
	elif number >= 2:
		number = number - 2
		result = result + 1
	elif number >= 1:
		number = number - 1
		result = result + 1
	if number == 0:
		break
print(result)


n = int(input())
count = 1
while n > 5:
	count += 1
	n -= 5
print(count)


import math
n = float(input())
print(math.ceil(n / 5))


distance = int(input())
steps = 0
while steps * 5 < distance:
	steps += 1
print(steps)


import math
x = int(input())
if x < 6:
	print(1)
else:
	print(math.ceil(x / 5))


x = int(input())
a = 0
while x > 0:
	if x >= 5:
		a += 1
		x -= 5
	elif x >= 4:
		a += 1
		x -= 4
	elif x >= 3:
		a += 1
		x -= 3
	elif x >= 2:
		a += 1
		x -= 2
	elif x >= 1:
		a += 1
		x -= 1
print(a)


n = int(input())
if n <= 5:
	print('1')
else:
	fives = n // 5
	if n % 5 == 0:
		print(fives)
	else:
		print(fives + 1)


l = int(input())
if l % 5 == 0:
	print(int(l / 5))
else:
	print(int(l / 5) + 1)


x = int(input(''))
count = 0
while x > 5:
	x -= 5
	count += 1
print(count + 1)


x = input()
x = int(x)
steps = (1, 2, 3, 4, 5)
a = x // 5
b = x % 5
if b > 0:
	count = a + 1
else:
	count = a
print(count)


n = int(input())
count = 0
while n > 0:
	if n >= 5:
		count += n // 5
		n = n % 5
	elif n >= 4:
		count += n // 4
		n = n % 4
	elif n >= 3:
		count += n // 3
		n = n % 3
	elif n >= 2:
		count += n // 2
		n = n % 2
	else:
		count += n
		n = 0
print(count)


import math
from collections import deque as dq

def si():
	return input()

def ii():
	return int(input())

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

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

def matr(n):
	return [list(mii()) for _ in range(n)]
i = ii()
print(math.ceil(i / 5))


f = int(input())
p = f
q = 5
summ = 0
while q != 0:
	summ = summ + p // q
	p = p % q
	q -= 1
print(summ)


n = int(input())
step = 5
ans = 0
while True:
	if n >= step:
		n -= step
		ans += 1
	else:
		step = 4
		break
while True:
	if n >= step:
		n -= step
		ans += 1
	else:
		step = 3
		break
while True:
	if n >= step:
		n -= step
		ans += 1
	else:
		step = 2
		break
while True:
	if n >= step:
		n -= step
		ans += 1
	else:
		step = 1
		break
while True:
	if n >= step:
		n -= step
		ans += 1
	else:
		step = 1
		break
print(ans)


x = int(input())
s = [5, 4, 3, 2, 1]
(ans, i) = (0, 0)
for _ in range(x):
	if x > s[i]:
		x -= s[i]
		ans += 1
	else:
		break
ans += 1
print(ans)


x = int(input())
step = 0
while True:
	if x == 0:
		break
	step += 1
	for i in [5, 4, 3, 2, 1]:
		if x - i >= 0:
			x = x - i
			break
		else:
			continue
print(step)


distance = int(input())
fives = distance // 5
distance -= fives * 5
if distance == 0:
	print(fives)
else:
	print(fives + 1)


kk = input()
n = int(kk)
total = 0
gg = n // 5
total += gg
if n % 5 != 0:
	total += 1
print(total)


n = int(input())
s = 0
s += n // 5
n = n % 5
s += n // 4
n = n % 4
s += n // 3
n = n % 3
s += n // 2
n = n % 2
s += n // 1
n = n % 1
print(s)


n = int(input())
sum = 0
while n > 0:
	sum = sum + 1
	n = n - 5
print(sum)


coordinate = input()
coordinate = int(coordinate)
print((coordinate - 1) // 5 + 1)


n = int(input())
steps = 0
for i in range(5, 0, -1):
	a = n // i
	steps = steps + a
	n = n - i * a
	if n == 0:
		break
print(steps)


n = int(input())
result = n // 5
if n % 5 > 0:
	result += 1
print(result)


remaining_distance = int(input())
end = False
steps = 0
while end == False:
	if 5 >= remaining_distance >= 1:
		steps += 1
		if remaining_distance == 5:
			remaining_distance -= 5
		if remaining_distance == 4:
			remaining_distance -= 4
		if remaining_distance == 3:
			remaining_distance -= 3
		if remaining_distance == 2:
			remaining_distance -= 2
		if remaining_distance == 1:
			remaining_distance -= 1
	elif remaining_distance >= 5:
		steps += 1
		remaining_distance -= 5
	elif remaining_distance == 0:
		end = True
print(steps)


import math
n = int(input())
result = math.ceil(n / 5)
print(result)


import math
import os
import random
import re
import sys
n = int(input())
a = n // 5
b = n - a
k = 0
if n < 5:
	k = 1
elif n % 5 == 0:
	k = n // 5
else:
	k = n // 5 + 1
print(k)


x = int(input())
val = 0
for i in range(5, 0, -1):
	if x != 0:
		val1 = int(x / i)
		val += val1
		x = x - val1 * i
	else:
		break
print(val)


m = int(input())
if m > 5:
	if m % 5 == 0:
		print(m // 5)
	else:
		print(m // 5 + 1)
else:
	print('1')


n = int(input())
c = 0
for i in range(5, 0, -1):
	c += n // i
	n %= i
print(c)


steps = [5, 4, 3, 2, 1]
n = int(input())
times = 0
while True:
	for step in steps:
		while n - step > -1:
			n -= step
			times += 1
		if n == 0:
			print(times)
			quit()


n = int(input())
d = n / 5
if d.is_integer():
	print(int(d))
else:
	print(n // 5 + 1)


n = int(input())
x = n
z = 0
for i in range(x):
	if n >= 5:
		n = n - 5
		z = z + 1
	elif 3 < n < 5:
		n = n - 4
		z = z + 1
	elif 2 < n < 4:
		n = n - 3
		z = z + 1
	elif 1 < n < 3:
		n = n - 2
		z = z + 1
	elif 0 < n < 2:
		n = n - 1
		z = z + 1
print(z)


a = int(input())
j = 0
j = j + a // 5
a = a - 5 * (a // 5)
j = j + a // 4
a = a - 4 * (a // 4)
j = j + a // 3
a = a - 3 * (a // 3)
j = j + a // 2
a = a - 2 * (a // 2)
j = j + a
print(j)


x = int(input())
c = 0
while 1:
	if x == 0:
		break
	if x - 5 >= 0:
		x = x - 5
		c = c + 1
		continue
	elif x - 4 >= 0:
		x = x - 4
		c = c + 1
		continue
	elif x - 3 >= 0:
		x = x - 3
		c = c + 1
		continue
	elif x - 2 >= 0:
		x = x - 2
		c = c + 1
		continue
	elif x - 1 >= 0:
		x = x - 1
		c = c + 1
		continue
print(c)


Distance = int(input())
moves = 0
while Distance > 5:
	Distance = Distance - 5
	moves += 1
moves += 1
print(moves)


from array import *
k = int(input())
ans = int(k / 5)
if k % 5 != 0:
	ans += 1
print(ans)


friend_x = int(input())
number_of_distances_of_five = int(friend_x / 5)
final_result = number_of_distances_of_five
if friend_x % 5 != 0:
	final_result = final_result + 1
print(final_result)


length = int(input())
(q, l) = divmod(length, 5)
if l:
	print(q + 1)
else:
	print(q)


n = int(input())
c = 0
while True:
	if n >= 5:
		s = n // 5
		c = c + s
		n = n % 5
	if n >= 4:
		s = n // 4
		c = c + s
		n = n % 4
	if n >= 3:
		s = n // 3
		c = c + s
		n = n % 3
	if n >= 2:
		s = n // 2
		c = c + s
		n = n % 2
	if n >= 1:
		s = n // 1
		c = c + s
		n = n % 1
	if n == 0:
		break
print(c)


s = i = 0
x = int(input())
for i in range(5, 0, -1):
	s = s + x // i
	x = x % i
print(s)


a = int(input())
b = a // 5
c = a - b * 5
d = c // 4
(e, f, g) = (0, 0, 0)
if d == 0:
	e = c // 3
	if e == 0:
		f = c // 2
		if f == 0:
			g = c // 1
h = b + d + e + f + g
print(h)


print(int((int(input()) - 1) / 5) + 1)


n = int(input())
res = 0
while n:
	res += n // 5
	n = n % 5
	if n == 0:
		break
	res += n // 4
	n = n % 4
	if n == 0:
		break
	res += n // 3
	n = n % 3
	if n == 0:
		break
	res += n // 2
	n = n % 2
	if n == 0:
		break
	res += n // 1
	n = n % 1
print(res)


n = int(input())
ind = 0
while n >= 5:
	n = n - 5
	ind += 1
while n >= 4:
	n = n - 4
	ind += 1
while n >= 3:
	n = n - 3
	ind += 1
while n >= 2:
	n = n - 2
	ind += 1
while n > 0:
	n = n - 1
	ind += 1
print(ind)


num = int(input())
answer = 0
for i in reversed(range(1, 6)):
	while num - i > 0:
		num -= i
		answer += 1
	if num - i == 0:
		answer += 1
		break
print(answer)


distance = int(input())
initial_steps = distance // 5
if distance % 5 != 0:
	initial_steps += 1
print(initial_steps)


n = int(input())
n1 = [1, 2, 3, 4, 5]
n2 = [0, 0, 0, 0, 0]
s = str()
for i in range(5):
	if n % n1[i] == 0:
		n2[i] = int(n / n1[i])
	else:
		n2[i] = int(n / n1[i] + 1)
print(min(n2))


n = int(input())
c = 0
i = 0
a = [5, 4, 3, 2, 1]
while n > 0:
	if n >= a[i]:
		n -= a[i]
		c += 1
	else:
		i += 1
print(c)


from math import ceil
x = int(input())
if x >= 1 and x <= 5:
	print(1)
elif x % 5 == 0:
	print(x // 5)
else:
	print(x // 5 + 1)


distance = int(input())
walk = 0
for i in range(5, 0, -1):
	if distance >= i:
		walk += distance // i
		distance -= distance // i * i
print(walk)


x = int(input())
step = 0
dist = 5
while x > 0:
	if x >= dist:
		step = step + x // dist
	x %= dist
	dist -= 1
print(step)


n = int(input())
b = -n // 5
print(abs(b))


n = int(input())
d = 0
d += n // 5
n = n % 5
d += n // 4
n = n % 4
d += n // 3
n = n % 3
d += n // 2
n = n % 2
d += n // 1
n = n % 1
print(d)


inp = input
li = list
iinp = lambda : int(inp())
ent = lambda : map(int, inp().split())
lient = lambda : li(ent())
n = iinp()
cinco = n // 5
n %= 5
cuatro = n // 4
n %= 4
tres = n // 3
n %= 3
dos = n // 2
n %= 2
print(cinco + cuatro + tres + dos + n)


p = int(input())
print(p // 5 + min(1, p % 5))


N = int(input())
if N % 5 == 0:
	print(N // 5)
else:
	print(N // 5 + 1)


a = int(input())
b = a / 5 + (a % 5 > 0)
if b == a / 5:
	print(int(b))
else:
	print(int(a // 5) + 1)


a = int(input())
if a % 5 == 0:
	N = a / 5
else:
	N = int(a / 5)
	a = a % 5
	if a % 4 == 0:
		N = N + a / 4
	else:
		N = N + int(a / 4)
		a = a % 4
		if a % 3 == 0:
			N = N + a / 3
		else:
			N = N + int(a / 3)
			a = a % 3
			if a % 2 == 0:
				N = N + a / 2
			else:
				N = N + int(a / 2)
				a = a % 2
				if a % 1 == 0:
					N = N + a / 1
				else:
					N = N + int(a / 1)
					a = a % 1
print(int(N))


import math
house_location = int(input())
print(math.ceil(house_location / 5))


x = int(input())
c = 0
for i in range(5, 0, -1):
	c += x // i
	x = x % i
print(c)


z = lambda x: x // 5 + int(x % 5 != 0)
print(z(int(input())))


number = int(input())
count = number // 5
remainder = number % 5
if remainder != 0:
	count += 1
print(count)


i = int(input())
if i <= 5:
	print('1')
else:
	s = i // 5
	if i % 5 == 0:
		print(s)
	else:
		print(s + 1)


n = int(input())
n = n - 1
print((n - 1 + 2 - 1) // 5 + 1)


n = int(input())
step = int(n / 5)
n = n % 5
step += int(n / 4)
n = n % 4
step += int(n / 3)
n = n % 3
step += int(n / 2)
n = n % 2
step += n
print(step)


from sys import stdin
from math import ceil
friends_location = int(stdin.readline().strip())
num_steps = ceil(friends_location / 5)
print(num_steps)


import math
n = int(input())
step = math.ceil(n / 5)
print(step)


n = int(input())
st = 0
st = st + n // 5
n %= 5
st = st + n // 4
n %= 4
st = st + n // 3
n %= 3
st = st + n // 2
n %= 2
st = st + n
print(st)


def elepnt_moves(c_x):
	stps = [1, 2, 3, 4, 5]
	cnt = 0
	d = len(stps) - 1
	while c_x > 0:
		while c_x >= stps[d]:
			c_x -= stps[d]
			cnt += 1
		d -= 1
	print(cnt)
n = int(input().strip(' '))
elepnt_moves(n)


friend = int(input())
moves = 0
for steps in range(5, 0, -1):
	moves += friend // steps
	friend = friend % steps
print(moves)


n = int(input())
k = 0
b = n % 5
c = n // 5
k = c
if b < 5 and b > 0:
	k = k + 1
print(k)


import sys
inf = float('inf')
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
(mod, MOD) = (1000000007, 998244353)
vow = ['a', 'e', 'i', 'o', 'u']
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def get_array():
	return list(map(int, sys.stdin.readline().strip().split()))

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

def input():
	return sys.stdin.readline().strip()
steps = int(input())
if steps <= 5:
	print(1)
else:
	ans = steps // 5
	if steps % 5 != 0:
		ans += 1
	print(ans)


x = int(input())
five = x // 5
x -= five * 5
four = x // 4
x -= four * 4
three = x // 3
x -= three * 3
two = x // 2
x -= two * 2
one = x
print(five + four + three + two + one)


step = int(input())
count = 0
while step != 0:
	count += 1
	if step < 5:
		step = step - step
		break
	elif step >= 5:
		step = step - 5
print(count)


inp = input()
a = int(inp)
x = 0
if a <= 5:
	print(1)
else:
	a = a / 5
	a = str(a)
	if int(a[-1]) == 0:
		print(int(float(a)))
	else:
		print(int(float(a) + 1))


from sys import stdin
x = int(stdin.readline())
print((x + 4) // 5)


x = int(input())
c = x
while c > 0:
	five = c // 5
	c -= five * 5
	four = c // 4
	c -= four * 4
	three = c // 3
	c -= three * 3
	two = c // 2
	c -= two * 2
	one = c // 1
	c -= one * 1
print(int(five + four + three + two + one))


ilo = int(input())
wyn = ilo // 5
if ilo % 5 != 0:
	wyn += 1
print(wyn)


steps = (5, 4, 3, 2, 1)

def solve(n):
	stepsCount = 0
	while n > 0:
		for step in steps:
			if n >= step:
				stepsCount += 1
				n -= step
				break
	return stepsCount
n = int(input())
print(solve(n))


import math
x = int(input(''))
b = math.ceil(x / 5)
print(b)


x_cordinate = int(input())
count = 0
elephant_moves = [1, 2, 3, 4, 5]
while x_cordinate >= 5:
	b = x_cordinate - max(elephant_moves)
	count += 1
	x_cordinate = b
	if x_cordinate == 5:
		count += 1
		break
else:
	while x_cordinate > 0:
		a = x_cordinate - max(elephant_moves)
		if a < 0:
			elephant_moves.remove(max(elephant_moves))
		elif a == 0:
			count += 1
			x_cordinate = a
print(count)


from math import *
x = int(input())
if x % 5 == 0:
	steps = x / 5
else:
	steps = x // 5 + 1
print(int(steps))


x = int(input())
steps = 0
if x % 5 == 0:
	print(int(x / 5))
else:
	print(x // 5 + 1)


a = int(input())
if a <= 5:
	print(1)
elif a % 5 == 0:
	print(int(a / 5))
elif a % 5 != 0:
	d = a // 5
	e = a % 5
	if e % 4 == 0:
		print(e // 4 + d)
	elif e % 3 == 0:
		print(e // 3 + d)
	elif e % 2 == 0:
		print(e // 2 + d)
	else:
		print(e + d)


x = int(input())
if x > 5 and x % 5 != 0:
	a = x // 5 + 1
	print(a)
elif x > 5 and x % 5 == 0:
	a = x / 5
	print(int(a))
else:
	print(1)


n = int(input())
c = n // 5
if n % 5 != 0:
	c += 1
print(c)


import math

def main():
	dist = int(input())
	if dist == 0:
		return 0
	if dist % 5 == 0:
		steps = 0
	else:
		steps = 1
	steps += dist // 5
	return steps
print(main())


import math
n = int(input())
if n <= 5:
	print(1)
else:
	a1 = int(math.ceil(n / 2))
	a2 = int(math.ceil(n / 3))
	a3 = int(math.ceil(n / 4))
	a4 = int(math.ceil(n / 5))
	a5 = min(a1, a2)
	a6 = min(a3, a4)
	ans = min(a5, a6)
	print(ans)


target = int(input())
cnt = 0
if target % 5 == 0:
	print(target // 5)
else:
	print(target // 5 + 1)


friend_loc = int(input())
five_step = friend_loc // 5
if friend_loc > 5 and friend_loc % 5 != 0:
	print(five_step + 1)
elif friend_loc > 5 and friend_loc % 5 == 0:
	print(five_step)
else:
	print(1)


a = int(input())
h = 1
while a >= 1:
	if a <= 5:
		print(h)
	a = a - 5
	h = h + 1


x = int(input())
j = 5
step = 0
for i in range(5):
	step += x // j
	x = x % j
	j -= 1
print(step)


n = int(input())
ctr = 0
while n:
	if n - 5 >= 0:
		n -= 5
		ctr += 1
		continue
	if n - 4 >= 0:
		n -= 4
		ctr += 1
		continue
	if n - 3 >= 0:
		n -= 3
		ctr += 1
		continue
	if n - 2 >= 0:
		n -= 2
		ctr += 1
		continue
	if n - 1 >= 0:
		n -= 1
		ctr += 1
		continue
print(ctr)


n = int(input())
if n <= 5:
	print(1)
elif n > 5:
	y = n // 5
	if n % 5 != 0:
		print(1 + y)
	else:
		print(y)


d = int(input())
print(int(bool(d % 5)) + d // 5)


n = int(input())
m = n // 5
if n % 5 != 0:
	m += 1
print(m)


x = int(input())
out = x // 5
if x % 5 >= 1:
	out += 1
print(out)


from math import ceil
n = int(input())
if n > 5:
	print(n // 5 + min(1, n % 5))
else:
	print(1)


x = int(input())
minimum = 0
for5 = x // 5
minimum += for5
x = x % 5
for4 = x // 4
minimum += for4
x = x % 4
for3 = x // 3
minimum += for3
x = x % 3
for2 = x // 2
minimum += for2
x = x % 2
minimum += x
print(minimum)


x = int(input())
q = x // 5
r = x % 5
if r == 0:
	print(q)
else:
	q = q + 1
	print(q)


s = int(input())
c = 1
while True:
	if s <= 5:
		break
	else:
		s = s - 5
		c = c + 1
print(c)


s = int(input()) + 4
print(s // 5)


n = int(input())
k = n // 5
ost = n % 5
k = k + ost // 4
ost = ost % 4
k = k + ost // 3
ost = ost % 3
k = k + ost // 2
ost = ost % 2
k = k + ost // 1
ost = ost % 1
print(k)


x = int(input())
n = 1
if x < 6:
	print(n)
else:
	while x > 5:
		x -= 5
		n += 1
	print(n)


t = int(input())
s = 0
while t >= 5:
	s += 1
	t -= 5
while t >= 4:
	s += 1
	t -= 4
while t >= 3:
	s += 1
	t -= 3
while t >= 2:
	s += 1
	t -= 2
while t >= 1:
	s += 1
	t -= 1
print(s)


n = int(input())
step = [5, 4, 3, 2, 1]
l = 0
t = 0
for i in step:
	l += int(n / i)
	n = n % i
print(int(l))


a = int(input())
b = [5, 4, 3, 2, 1]
i = 0
count = 0
while a != 0 and i < 5:
	if a >= b[i]:
		count += 1
		a = a - b[i]
	else:
		i += 1
print(count)


dis = int(input())
five = dis // 5
rem1 = dis - 5 * five
four = rem1 // 4
rem2 = rem1 - 4 * four
three = rem2 // 3
rem3 = rem2 - 3 * three
two = rem3 // 2
rem4 = rem3 - 2 * two
print(int(five + four + three + two + rem4))


x = int(input())
a = x // 5
b = x % 5
if b != 0:
	a += 1
print(a)


n = int(input())
count = 0
if n in (1, 2, 3, 4, 5):
	print(1)
else:
	count += n // 5
	n -= n // 5 * 5
	if n >= 4:
		count += n // 4
		n -= n // 4 * 4
	if n >= 3:
		count += n // 3
		n -= n // 3 * 3
	if n >= 2:
		count += n // 2
		n -= n // 2 * 2
	if n >= 1:
		count += n
	print(count)


x = int(input())
t = int(x / 5)
if x % 5 == 0:
	print(t)
else:
	print(t + 1)


import math as m
n = int(input())
print(m.ceil(n / 5))


class Solution(object):

	def __init__(self):
		data = int(input())
		ans = data // 5
		if data % 5:
			ans += 1
		print(ans)
	pass

def main():
	Solution()
	pass
main()


import math
k = int(input())
print(k // 10 * 2 + math.ceil(k % 10 / 5))


def minSteps(x: int) -> int:
	res = x // 5
	if x % 5 != 0:
		res += 1
	return res

def main():
	x = int(input())
	print(minSteps(x))
main()


print(int(int(input()) / 5 + 0.9))


import math
y = int(input())
x = 0
if y >= 5:
	x += math.ceil(y / 5)
	y = y - math.ceil(y / 5) * 5
if y == 4:
	x += 1
	y = 0
if y == 3:
	x += 1
	y = 0
if y == 2:
	x += 1
	y = 0
if y == 1:
	x += 1
	y = 0
print(x)


n = int(input())
p = n + 4
t = 5
print(p // t)


x = int(input())
v = 0
if x % 5 > 0:
	v = 1
print(x // 5 + v)


dist = int(input())
time = dist // 5
if dist % 5 > 0:
	time += 1
print(str(time))


ans = (int(input()) + 4) // 5
print(ans)


point = int(input())
i = 5
result = 0
while i:
	if point % i == 0:
		result += int(point / i)
		print(result)
		exit(0)
	else:
		result += int(point // i)
		point %= i
	i -= 1


n = int(input())
res = 0
res += n // 5
n = n % 5
res += n // 4
n = n % 4
res += n // 3
n = n % 3
res += n // 2
n = n % 2
res += n // 1
print(res)


n = int(input())
if n % 5 != 0:
	v = n // 5 + 1
else:
	v = n // 5
print(v)


n = int(input())
c = 0
for x in (5, 4, 3, 2, 1):
	if n >= x:
		c += n // x
		n = n % x
print(c)


w = int(input())
if w % 5 == 0:
	print(int(w / 5))
else:
	b = w / 5 + 1
	print(int(b))


num = int(input())
count = num // 5
if num % 5 != 0:
	count += 1
print(count)


x = int(input())
if x % 5 == 0:
	print(x // 5)
	exit()
print(x // 5 + 1)


num = int(input())
count = 0
temp = 5
while num > 0:
	if num - temp >= 0:
		num = num - temp
		count += 1
	else:
		temp = temp - 1
print(count)


x = int(input())
r = x % 5
devide = (x - r) / 5
if r != 0:
	steps = int(devide + 1)
else:
	steps = int(devide)
print(steps)


print(int(int(input()) + 4) // 5)


def func(num):
	count = 0
	lst = [5, 4, 3, 2, 1]
	for i in lst:
		count += num // i
		num = num % i
		if num == 0:
			return count
print(func(int(input())))


x = int(input())
point = 0
for i in range(5, 0, -1):
	point += x // i
	x -= x // i * i
print(point)


user_input = int(input())
list = [5, 4, 3, 2, 1]
count = 0
for i in list:
	if user_input % i == 0:
		count += user_input // i
		break
	else:
		count += user_input // i
		user_input = user_input % i
print(count)


import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from functools import lru_cache
import bisect
import re
import queue

class Scanner:

	@staticmethod
	def int():
		return int(sys.stdin.readline().rstrip())

	@staticmethod
	def string():
		return sys.stdin.readline().rstrip()

	@staticmethod
	def map_int():
		return [int(x) for x in Scanner.string().split()]

	@staticmethod
	def string_list(n):
		return [input() for i in range(n)]

	@staticmethod
	def int_list_list(n):
		return [Scanner.map_int() for i in range(n)]

	@staticmethod
	def int_cols_list(n):
		return [int(input()) for i in range(n)]

class Math:

	@staticmethod
	def gcd(a, b):
		if b == 0:
			return a
		return Math.gcd(b, a % b)

	@staticmethod
	def lcm(a, b):
		return a * b // Math.gcd(a, b)

	@staticmethod
	def divisor(n):
		res = []
		i = 1
		for i in range(1, int(n ** 0.5) + 1):
			if n % i == 0:
				res.append(i)
				if i != n // i:
					res.append(n // i)
		return res

	@staticmethod
	def round_up(a, b):
		return -(-a // b)

	@staticmethod
	def is_prime(n):
		if n < 2:
			return False
		if n == 2:
			return True
		if n % 2 == 0:
			return False
		d = int(n ** 0.5) + 1
		for i in range(3, d + 1, 2):
			if n % i == 0:
				return False
		return True

class PriorityQueue:

	def __init__(self, l=[]):
		self.q = l
		heapq.heapify(self.q)
		return

	def push(self, n):
		heapq.heappush(self.q, n)
		return

	def pop(self):
		return heapq.heappop(self.q)
MOD = int(1000000000.0) + 7
INF = int(1000000000000000.0)

def main():
	x = Scanner.int()
	print(Math.round_up(x, 5))
main()


import math
co = int(input())
print(math.ceil(co / 5))


from math import ceil
n = int(input())
ans = ceil(n / 5)
print(ans)


n = int(input())
(a, b) = divmod(n, 5)
if b > 0:
	print(a + 1)
else:
	print(a)


nnumber = int(input())
elephant = 0
p = 0
j = 0
if nnumber == 0:
	print(0)
else:
	while nnumber >= 5:
		nnumber -= 5
		p += 1
	if nnumber == 0:
		print(p)
	else:
		p += 1
		print(p)


x = int(input())
print(x // 5 + min(x % 5, 1))


possible_steps = [1, 2, 3, 4, 5]
steps_to_take = 0
location = int(input())
if location <= 5:
	steps_to_take = 1
if location > 5:
	steps_to_take = location // 5
	if location % 5 in possible_steps:
		steps_to_take += 1
print(steps_to_take)


import math
n = int(input())
if n <= 5:
	print('1')
else:
	print(math.ceil(n / 5))


def op_bank(a):
	k = 0
	nomin = [5, 4, 3, 2, 1]
	for n in nomin:
		c = a // n
		a -= n * c
		k += c
	return k
a = int(input())
print(op_bank(a))


num = int(input())
num1 = num / 5
num2 = num % 5
import math
if num2 == 0:
	print(math.ceil(num1))
else:
	print(math.floor(num1) + 1)


def main():
	import math
	n = int(input())
	print(math.ceil(n / 5))
main()


def shagi(number):
	s = [1, 2, 3, 4]
	if number % 5 == 0:
		return number // 5
	elif number % 5 in s:
		return number // 5 + 1
print(shagi(int(input())))


inp = int(input())
num = int()
matrix = [5, 4, 3, 2, 1]
for x in matrix:
	if inp != 0:
		num = num + int(inp / x)
		inp = inp % x
print(num)


n = int(input())
print(n // 5 + bool(n % 5))


a = int(input())
y = 0
if a % 5 > 0:
	y = 1
x = a // 5 + y
print(x)


n = int(input())
ar = [5, 4, 3, 2, 1]
t = 0
for i in range(len(ar)):
	t += n // ar[i]
	n %= ar[i]
	i += 1
	if n == 1:
		t += 1
		break
print(t)


x = int(input())
r = x // 5
x = x - r * 5
if not x == 0:
	r += 1
print(r)


from math import *
a = int(input())
b = ceil(a / 5)
print(b)


n = int(input())
c = n // 5
rm = n % 5
if rm:
	print(c + 1)
else:
	print(c)


x = int(input())
count = 0
for i in list(range(1, 6))[::-1]:
	count += x // i
	x = x % i
print(count)


n = int(input())
st = [5, 4, 3, 2, 1]
ans = 0
for i in range(0, 5):
	ans += n // st[i]
	n = n % st[i]
print(ans)


n = int(input())
c = 0
while n != 0:
	if n >= 5:
		n = n - 5
		c = c + 1
	elif n < 5 and n >= 4:
		n = n - 4
		c = c + 1
	elif n < 4 and n >= 3:
		n = n - 3
		c = c + 1
	elif n < 3 and n >= 2:
		n = n - 2
		c = c + 1
	else:
		n = n - 1
		c = c + 1
print(c)


x = int(input())
steps = 0
for i in range(5, 0, -1):
	(s, r) = divmod(x, i)
	steps += s
	x = r
	if r == 0:
		break
print(steps)


x = int(input())
step = 0
if x >= 5:
	if x % 5 == 0:
		step = step + int(x // 5)
	if x % 5 != 0:
		step = step + int(x // 5) + 1
else:
	step = step + 1
print(step)


x = int(input())
s = 0
s = x // 5
x = x % 5
s += x // 4
x = x % 4
s += x // 3
x = x % 3
s += x // 2
x = x % 2
print(x + s)


x = int(input())
a = (x - 1) // 5
print(a + 1)


n = int(input())
print((n + 4) // 5)


n = int(input())
cost = 0
cost += int(n / 5)
n %= 5
cost += int(n / 4)
n %= 4
cost += int(n / 3)
n %= 3
cost += int(n / 2)
n %= 2
cost += int(n / 1)
n %= 1
print(int(cost))


def solve(n):
	ans = 0
	temp = n
	while n != 0:
		bills = [5, 4, 3, 2, 1]
		for b in bills:
			if n >= b:
				n %= b
				ans += (temp - n) / b
				temp = n
				break
	return int(ans)
n = int(input())
print(solve(n))


x = int(input())
n_5 = int(x / 5)
min_steps = n_5 + 1 if x % 5 != 0 else n_5
print(min_steps)


print((lambda x: x // 5 + round(x % 5 / 21 + 0.5))(int(input())))


from math import ceil
x = int(input())
if x <= 5:
	step = 1
elif x > 5:
	step = ceil(x / 5)
print(step)


import math
x = int(input().strip())
steps = math.floor(x / 5)
if x % 5 != 0:
	steps += 1
print(steps)


x = int(input())
step = 0
option = [5, 4, 3, 2, 1]
for num in option:
	step += x // num
	x = x % num
print(step)


x = int(input())
(d, s, out) = (0, 5, 0)
while d < x:
	if d + s <= x:
		d += s
		out += 1
	else:
		s -= 1
print(out)


n = input()
n = int(n)
x = [5, 4, 3, 2, 1]
gesamt = 0
for i in range(0, len(x)):
	if n < x[i]:
		continue
	else:
		rest = n % x[i]
		x_rest = (n - rest) / x[i]
		gesamt = gesamt + x_rest
		n = rest
print(int(gesamt))


import math
import re
a = int(input())
b = math.floor(a / 5)
b = [b, b - 1][b == a / 5]
print(b + 1)


coordinate = int(input())
stepcounter = 0
if coordinate % 5 == 0:
	stepcounter += coordinate // 5
elif coordinate % 5 > 0:
	stepcounter += coordinate // 5 + 1
print(stepcounter)


from math import log, ceil
distance = int(input())
somme = []
somme.append(distance // 5)
distance = distance % 5
somme.append(distance // 4)
distance = distance % 4
somme.append(distance // 3)
distance = distance % 3
somme.append(distance // 2)
distance = distance % 2
somme.append(distance // 1)
print(sum(somme))


from math import ceil, sqrt, gcd

def ii():
	return int(input())

def si():
	return input()

def mi():
	return map(int, input().strip().split(' '))

def li():
	return list(mi())
x = ii()
c = x // 5
x %= 5
if x == 0:
	print(c)
else:
	print(c + 1)


distance = int(input())
count = 0
while distance > 5:
	distance -= 5
	count += 1
if distance > 0:
	count += 1
print(count)


import math
x = int(input())
steps = [5, 4, 3, 2, 1]
count = 0
if x > 5:
	while x > 0:
		for step in steps:
			if x - step >= 0:
				x -= step
				count += 1
				break
	print(count)
else:
	print(1)


x = int(input())
d = 5
r = 0
while x > 0:
	if int(x / d) * d != 0:
		r = r + int(x / d)
		x = x - int(x / d) * d
	d = d - 1
print(r)


x = int(input())
n = 1
while x > 5:
	x -= 5
	n += 1
print(n)


numbers = [1, 2, 3, 4]
x = int(input())
(nsteps, m) = divmod(x, 5)
if m == 0:
	print(nsteps)
elif m in numbers:
	print(nsteps + 1)


import math
import cmath
from decimal import *
from fractions import *
n = int(input())
(res, x) = (0, 5)
while x:
	res += n // x
	n %= x
	x -= 1
print(res)


a = int(input())
bla = 0
for i in reversed(range(1, 6)):
	bla = bla + a // i
	a = a % i
print(bla)


n = int(input())
a = 0
x = n % 5
p = x % 4
z = p % 3
e = z % 2
a += n // 5 + x // 4 + p // 3 + z // 2 + e
print(a)


x = int(input())
c = 0
c += x // 5
x = x % 5
c += x // 4
x = x % 4
c += x // 3
x = x % 3
c += x // 2
c += x % 2
print(c)


import sys
import math
print(math.ceil(int(input()) / 5))


dist = int(input())
bigsteps = int(dist / 5)
if dist % 5 == 0:
	print(bigsteps)
else:
	print(bigsteps + 1)


num = int(input())
cont = 0
while num > 0:
	num -= 5
	cont += 1
print(cont)


n = int(input())
a = n // 5
n = n % 5
b = n // 4
n = n % 4
c = n // 3
n = n % 3
d = n // 2
n = n % 2
print(a + b + c + d + n)


n = int(input())
if n % 5 == 0:
	u = n / 5
else:
	k = n / 5
	u = k + 1
print(int(u))


a = int(input())
l = []
if a % 5 != 0:
	x = a // 5
	l.append(x)
	a = a - x * 5
if a % 5 == 0:
	x = a // 5
	l.append(x)
	a = 0
if a % 4 != 0:
	x = a // 4
	l.append(x)
	a = a - x * 4
if a % 4 == 0:
	x = a // 4
	l.append(x)
	a = 0
if a % 3 != 0:
	x = a // 3
	l.append(x)
	a = a - x * 3
if a % 3 == 0:
	x = a // 3
	l.append(x)
	a = 0
if a % 2 != 0:
	x = a // 2
	l.append(x)
	a = a - x * 2
if a % 2 == 0:
	x = a // 2
	l.append(x)
	a = 0
if a == 1:
	l.append(1)
print(int(sum(l)))


x = int(input())
p = 0
ch = 0
s = 0
d = 0
y = 0
j = -1
if x >= 5:
	p = x // 5
	x = x - p * 5
	j = 1
if 5 > x >= 4 or j == 1:
	ch = x // 4
	x = x - ch * 4
	j = 1
if 4 > x >= 3 or j == 1:
	s = x // 3
	x = x - s * 3
	j = 1
if 3 > x >= 2 or j == 1:
	d = x // 2
	x = x - d * 2
	j = 1
if 2 > x or j == 1:
	y = x // 1
print(s + ch + d + p + y)


n = int(input())
if n <= 5:
	print(1)
elif n % 5 == 0:
	print(n // 5)
else:
	a = n // 5
	print(a + 1)


distance = int(input())
steps = list(range(1, 6))
if distance in steps:
	print(1)
elif distance % 5 != 0:
	print(distance // 5 + 1)
else:
	print(distance // 5)


c = int(input())
if c <= 5:
	print('1')
elif int(c % 5) != 0:
	print(int(c / 5) + 1)
else:
	print(int(c / 5))


foo = int(input())
print((foo + 4) // 5)


x = int(input())
sum = 0
n = 5
while x > 0 and n > 0:
	sum = sum + x // n
	x = x - n * (x // n)
	n = n - 1
print(sum)


def fun(n):
	if n <= 5:
		return 1
	elif n % 5 == 0:
		return n // 5
	else:
		return n // 5 + 1
print(fun(int(input())))


def main():
	n = int(input())
	moves = 0
	while n > 0:
		if n // 5 > 0:
			moves += n // 5
			n -= 5 * moves
		elif n // 4 > 0:
			moves += n // 4
			n -= 4 * moves
		elif n // 3 > 0:
			moves += n // 3
			n -= 3 * moves
		elif n // 2 > 0:
			moves += n // 2
			n -= 2 * moves
		elif n // 1 > 0:
			moves += n // 1
			n -= moves
	print(moves)
main()


line1 = int(input())
if line1 % 5 == 0:
	print(line1 // 5)
else:
	print(line1 // 5 + 1)


a = int(input())
k = 0
while a != 0:
	while a >= 5:
		a = a - 5
		k = k + 1
		if a < 5:
			break
	if a == 4:
		a = a - 4
		k = k + 1
	elif a == 3:
		a = a - 3
		k = k + 1
	elif a == 2:
		a = a - 2
		k = k + 1
	elif a == 1:
		a = a - 1
		k = k + 1
print(k)


n = int(input())
i = 0
j = 0
while i < n:
	i = i + 5
	j += 1
print(j)


x = int(input())
steps = 0
for d in [5, 4, 3, 2, 1]:
	steps = steps + x // d
	x = x % d
print(steps)


n = int(input())
rem = n % 5
div = n // 5
if rem != 0:
	print(div + 1)
else:
	print(div)


import math
friend_pos = int(input())
print(int(math.ceil(friend_pos / 5)))


from math import trunc
a = int(input())
b = trunc(a / 5)
if a % 5 > 0:
	b += 1
print(b)


n = int(input())
f = 0
for i in range(5, 0, -1):
	f += n // i
	n = n % i
print(f)


def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

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

def li():
	return list(mi())
import math
x = ii()
print(math.ceil(x / 5))


n = int(input().strip())
steps = 0
for i in [5, 4, 3, 2, 1]:
	steps += n // i
	n = n % i
print(steps)


import math
x = int(input())
if x % 5 == 0:
	x = int(x / 5)
	print(x)
else:
	k = x / 5
	print(math.ceil(k))


(x, h, i) = (int(input()), 0, 0)
c = [5, 4, 3, 2, 1]
while x > 0:
	if x // c[i] > 0:
		h += x // c[i]
		x -= x // c[i] * c[i]
	i += 1
print(h)


line = int(input())
min_num = 0
for i in range(5, 0, -1):
	min_num += line // i
	line %= i
print(min_num)


x = int(input())
f = 1
m = 0
while f == 1:
	if x == 1:
		x = x - 1
		m = m + 1
	if x == 2:
		x = x - 2
		m = m + 1
	if x == 3:
		x = x - 3
		m = m + 1
	if x == 4:
		x = x - 4
		m = m + 1
	if x >= 5:
		x = x - 5
		m = m + 1
	if x == 0:
		f = f + 1
print(m)


n = int(input())
m = n
x = 0
mm = n % 5
if mm == 0:
	x = m // 5
	print(x)
elif m > 5:
	x = m // 5
	print(x + 1)
elif n <= 5:
	print('1')


x = int(input())
steps = x // 5
x = x % 5
if x:
	steps += 1
print(steps)


import math
import os
import random
import re
import sys
n = int(input())
count = 0
while n > 0:
	n = n - 5
	count = count + 1
print(count)


x = int(input())
i = 0
while x != 0:
	if x in [1, 2, 3, 4, 5]:
		i += 1
		break
	else:
		x -= 5
		i += 1
print(i)


s = int(input())
d = int(s / 5)
if s % 5 == 0:
	print(d)
else:
	print(d + 1)


n = int(input())
output = 0
while n > 5:
	n -= 5
	output += 1
if n < 5 or n > 0:
	output += 1
print(output)


def elephant(x):
	count = 0
	while x >= 0:
		count += 1
		if x >= 5:
			x -= 5
		elif x >= 4:
			x -= 4
		elif x >= 3:
			x -= 3
		elif x >= 2:
			x -= 2
		else:
			x -= 1
	return count - 1
x = int(input())
print(elephant(x))


n = int(input())
i = 1
p = [1, 2, 3, 4, 5]
while i != 10 ** 9:
	if n in p:
		print(i)
		break
	elif n == 0:
		print(0)
		break
	elif n not in p:
		n = n - 5
	i = i + 1


import math
n = int(input())
w = math.ceil(n / 5)
print(w)


n = int(input())
list = [5, 4, 3, 2, 1]
out = 0
i = 0
while n != 0:
	if n >= list[i]:
		n = n - list[i]
		out += 1
	else:
		i += 1
print(out)


x = int(input())
s = 0
while True:
	if x - 5 >= 0:
		x -= 5
		s += 1
		if x == 0:
			break
	elif x % 2 == 0:
		if x - 4 == 0:
			x -= 4
			s += 1
			break
		else:
			x -= 2
			s += 1
			break
	elif x % 3 == 0:
		x -= 3
		s += 1
		break
	else:
		x -= 1
		s += 1
		break
print(s)


dist = int(input())
res = divmod(dist, 5)
if dist <= 5:
	step = 1
elif res[1] == 0:
	step = res[0]
else:
	step = res[0] + 1
print(step)


a = int(input())
nombre_pas = 0
for i in range(5, 0, -1):
	nombre_pas += a // i
	a = a % i
print(nombre_pas)


x = int(input())
(c, i) = (0, 5)
while x != 0:
	if x - i >= 0:
		x -= i
		c += 1
	else:
		i -= 1
print(c)


n = int(input())
val = 0
for i in range(5, 0, -1):
	val = val + n // i
	n = n % i
print(val)


a = int(input())
c = a // 5
if a - c * 5 < 5 and a - c * 5 > 0:
	print(c + 1)
else:
	print(c)


nums = [5, 4, 3, 2, 1]
n = int(input())
cntr = 0
for x in nums:
	cntr += n // x
	n %= x
print(cntr)


(x, p, c) = (int(input()), 0, 0)
while p < x:
	if x - p >= 5:
		p += 5
		c += 1
	else:
		p += x - p
		c += 1
print(c)


s = int(input())
m = 0
for i in range(5)[::-1]:
	m += s // (i + 1)
	s = s % (i + 1)
print(m)


y = int(input())
m = (y + 4) // 5
print(m)


x = int(input())
l = 5
result = x // l
if x % l:
	result += 1
print(result)


import math
n = int(input())
if n % 5 == 0:
	print(math.floor(n / 5))
else:
	print(math.floor(n / 5 + 1))


n = int(input())
k = 0
if n >= 5:
	k += int(n / 5)
	n %= 5
if n >= 4:
	k += int(n / 4)
	n %= 4
if n >= 3:
	k += int(n / 3)
	n %= 3
if n >= 2:
	k += int(n / 2)
	n %= 2
if n >= 1:
	k += int(n / 1)
	n %= 1
print(k)


data = input()
n = int(data)
temp = 0
a = 5
while n != 0:
	temp = temp + int(n / a)
	n = n - a * int(n / a)
	a = a - 1
print(temp)


n = int(input())
cnt = 1
while n > 5:
	cnt += 1
	n -= 5
print(cnt)


print(__import__('math').ceil(int(input()) / 5))


import math
distance = int(input())
print(math.ceil(distance / 5))


import math
n = int(input())
if n % 5 == 0:
	c = n / 5
	print(int(c))
else:
	print(math.ceil(n / 5))


x = int(input())
summ = 0
count = 0
while x > summ:
	if x - summ >= 5:
		summ += 5
		count += 1
	else:
		count += 1
		break
print(count)


targ = int(input())
stepL = [1, 2, 3, 4, 5]
steps = 0
cor = 0
k = 4
while cor != targ:
	if targ - cor >= stepL[k]:
		cor += stepL[k]
		steps += 1
	else:
		k -= 1
print(steps)


elephantLoc = 0
friendLoc = int(input())
moves = [1, 2, 3, 4, 5]
overall = 0
while elephantLoc < friendLoc:
	if friendLoc >= moves[4]:
		elephantLoc += moves[4]
	elif friendLoc >= moves[3]:
		elephantLoc += moves[3]
	elif friendLoc >= moves[2]:
		elephantLoc += moves[2]
	elif friendLoc >= moves[1]:
		elephantLoc += moves[1]
	else:
		elephantLoc += moves[0]
	overall += 1
print(overall)


moves = [5, 4, 3, 2, 1]
destination = int(input())
min_moves = 0
while destination > 0:
	if moves[0] <= destination:
		min_moves += destination // moves[0]
		destination %= moves[0]
	else:
		moves.pop(0)
print(min_moves)


x = int(input())
count = x // 5
x = x % 5
count += x // 4
x = x % 4
count += x // 3
x = x % 3
count += x // 2
x = x % 2
count += x // 1
print(count)


a = int(input())
newa = a
steps = 0
for i in range(0, a):
	if newa - 5 >= 0:
		steps += 1
		newa -= 5
	elif newa - 4 >= 0:
		newa -= 4
		steps += 1
	elif newa - 3 >= 0:
		steps += 1
		newa -= 3
	elif newa - 2 >= 0:
		steps += 1
		newa -= 2
	elif newa - 1 >= 0:
		steps += 1
		newa -= 1
print(steps)


x = int(input())
tedad = x // 5
if x % 5 != 0:
	tedad += 1
print(tedad)


import math
s = int(input())
a = math.ceil(s / 5)
print(a)


x = int(input())
count = 0
while x >= 5:
	u = x // 5
	count = count + u
	x = x % 5
while x >= 4:
	b = x // 4
	count = count + b
	x = x % 4
while x >= 3:
	u = x // 3
	count = count + u
	x = x % 3
while x >= 2:
	u = x // 2
	count = count + u
	x = x % 2
count = count + x
print(count)


n = int(input())
s = 0
q = 6
w = 0
for i in range(0, 5):
	if n != 0:
		q = q - 1
		w = n // q
		s = s + w
		n = n - w * q
	else:
		break
print(s)


value = int(input())
if value % 5 == 0:
	print(value // 5)
else:
	print(value // 5 + 1)


coordinate = int(input(''))
step = 0
while coordinate >= 5:
	step += 1
	coordinate -= 5
while coordinate >= 4:
	step += 1
	coordinate -= 4
while coordinate >= 3:
	step += 1
	coordinate -= 3
while coordinate >= 2:
	step += 1
	coordinate -= 2
while coordinate >= 1:
	step += 1
	coordinate -= 1
print(step)


import sys
x = int(sys.stdin.readline())
steps = [1, 2, 3, 4, 5]

def elephant(x):
	min_steps = 0
	i = 4
	while x > 0:
		min_steps += x // steps[i]
		x -= x // steps[i] * steps[i]
		i -= 1
	print(min_steps)
elephant(x)


a = int(input())
counter = 0
while a >= 5:
	a -= 5
	counter += 1
while a >= 4:
	a -= 4
	counter += 1
while a >= 3:
	a -= 3
	counter += 1
while a >= 2:
	a -= 2
	counter += 1
while a >= 1:
	a -= 1
	counter += 1
print(counter)


x = int(input())
steps = 0
while x:
	if x < 5:
		steps += 1
		break
	steps += 1
	x -= 5
print(steps)


destination = int(input())
max_hop = 5
no_of_hops = 0
if destination != 0:
	while destination > 0:
		if destination > 5:
			destination = destination - 5
			no_of_hops += 1
		else:
			destination -= destination
			no_of_hops += 1
else:
	print(0)
print(no_of_hops)


c = int(input())
n = 0
while c >= 6:
	c -= 5
	n += 1
print(n + 1)


s = int(input())
nom = 0
a = int(s / 5)
s = s - a * 5
nom += a
a = int(s / 4)
s = s - a * 4
nom += a
a = int(s / 3)
s = s - a * 3
nom += a
a = int(s / 2)
s = s - a * 2
nom += a
a = int(s / 1)
s = s - a * 1
nom += a
print(nom)


x = int(input())
sum = 0
while x > 0:
	if x >= 5:
		x -= 5
		sum += 1
	else:
		x -= x
		sum += 1
print(sum)


def solve(coordinate):
	if coordinate % 5 != 0:
		first_step = coordinate / 5
		total = int(first_step) + 1
	else:
		total = coordinate / 5
	return int(total)
location = int(input())
print(solve(location))


x = int(input())
mn = 1e+18
for i in range(1, 6):
	if not x % i:
		mn = min(mn, x // i)
	else:
		mn = min(mn, 1 + x // i)
print(mn)


dis = int(input())
if dis <= 5:
	print(1)
else:
	(steps, r) = (dis // 5, dis % 5)
	if r == 0:
		print(steps)
	elif r % 1 == 0 or r % 2 == 0 or r % 3 == 0 or (r % 4 == 0):
		steps += 1
		print(steps)


distance = int(input())
steps = 0
while distance > 0:
	if distance >= 5:
		steps += 1
		distance -= 5
	elif distance >= 4:
		steps += 1
		distance -= 4
	elif distance >= 3:
		steps += 1
		distance -= 3
	elif distance >= 2:
		steps += 1
		distance -= 2
	elif distance >= 1:
		steps += 1
		distance -= 1
print(steps)


n = int(input())
answ = n // 5
if n % 5 > 0:
	answ += 1
print(answ)


n = int(input())
d = 0
for i in range(5, 0, -1):
	d += n // i
	n = n % i
print(d)


x = int(input())
ans = 0
rem = 0
for i in [5, 4, 3, 2, 1]:
	ans += x // i
	rem = x % i
	x = rem
print(int(ans))


n = int(input())
if n / 5 > round(n / 5):
	b = round(n / 5) + 1
else:
	b = round(n / 5)
print(b)


def solve(n):
	if n == 0:
		return 0
	if n <= 5:
		return 1
	return n // 5 + solve(n % 5)
print(solve(int(input())))


x = int(input())
currentPosition = 0
answer = 0
while currentPosition < x:
	i = x - currentPosition
	currentPosition += i if i < 5 else 5
	answer += 1
print(answer)


import math

def ii():
	return int(input())

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

def li():
	return list(mi())
n = ii()
f = 0
if n <= 5:
	f = 1
	print(f)
elif n % 5 == 0:
	f = n // 5
	print(f)
else:
	f = math.floor(n / 5)
	print(f + 1)


from sys import stdin, stdout
from math import ceil
inp = stdin.readline
out = stdout.write
n = int(inp().strip())
s = ceil(n / 5)
out(str(s))


z = input()
x = int(z)
cnt = 0
while x > 0:
	if x >= 5:
		x -= 5
		cnt += 1
	elif x < 5:
		x -= 4
		cnt += 1
print(cnt)


n = int(input())
m = n // 5
if n > 5 and n % 5 != 0:
	print(m + 1)
elif n % 5 == 0:
	print(m)
else:
	print(1)


x = int(input())
res = [0 for i in range(5)]
for i in range(1, 6):
	res[i - 1] = x // (5 - i + 1)
	x -= res[i - 1] * (5 - i + 1)
print(sum(res))


n = int(input())
print([n // 5 + 1, n // 5][n % 5 == 0])


def solve(n):
	if n <= 5:
		return 1
	elif n % 5 == 0:
		return n // 5
	else:
		x = n // 5
		return x + 1
n = int(input())
print(solve(n))


n = int(input())
if n <= 5:
	print(1)
	exit()
if n > 5 and n % 5 != 0:
	print(n // 5 + 1)
else:
	print(n // 5)


x = int(input())
pos = [5, 4, 3, 2, 1]
ans = 0
while x != 0:
	for i in range(len(pos)):
		if x >= pos[i]:
			x -= pos[i]
			break
	ans += 1
print(ans)


n = int(input())
count = n // 5 + 1
if n > 5 and n % 5 != 0:
	print(count)
elif n % 5 == 0:
	print(count - 1)
else:
	print(1)


n = int(input())
out = 0
for _ in range(n * 2):
	if n <= 0:
		break
	elif n >= 5:
		n -= 5
	else:
		n -= n
	out += 1
print(out)


n = int(input())
add = n % 5
base = n // 5
if add != 0:
	add = 1
print(base + add)


x = int(input())
steps = 0
while x >= 5:
	x -= 5
	steps += 1
if x <= 5 and x > 0:
	x -= x
	steps += 1
print(steps)


n = int(input())
count = 0
for i in range(5, 0, -1):
	count += int(n / i)
	n = n % i
	if n == 0:
		break
print(count)


n = int(input())
k = 0
t = 5
while n != 0:
	if n // t > 0:
		k = k + n // t
		n = n % t
	else:
		t = t - 1
print(k)


i = int(input())
j = 0
while i != 0:
	if i >= 5:
		i -= 5
		j += 1
	elif i >= 4:
		i -= 4
		j += 1
	elif i >= 3:
		i -= 3
		j += 1
	elif i >= 2:
		i -= 2
		j += 1
	elif i >= 1:
		i -= 1
		j += 1
print(j)


n = int(input())
if n == 1 or n == 2 or n == 3 or (n == 4) or (n == 5):
	print('1')
elif n > 5:
	s = n // 5
	r = n % 5
	if r == 0:
		print(s)
	else:
		print(s + 1)


a = int(input())
x = 0
i = 5
while a > 0:
	x = x + a // i
	a = a % i
	i = i - 1
print(x)


n = int(input())
count = 0
moves = [5, 4, 3, 2, 1]
for move in moves:
	count += n // move
	n = n % move
print(count)


a = int(input())
print(-(-a // 5))


x = int(input())
pos = 0
steps = 0
while True:
	if x - pos == 1:
		steps += 1
		pos += 1
	elif x - pos == 2:
		steps += 1
		pos += 2
	elif x - pos == 3:
		steps += 1
		pos += 3
	elif x - pos == 4:
		steps += 1
		pos += 4
	elif x - pos == 5:
		steps += 1
		pos += 5
	elif x > pos:
		steps += 1
		pos += 5
	elif x == pos:
		break
print(steps)


n = int(input())
a = n // 5
if n == a * 5:
	step = a
else:
	step = a + 1
print(step)


x = int(input())
l = [5, 4, 3, 2, 1]
n = x
steps = 0
if n in l:
	print('1')
else:
	while n != 0:
		steps += int(n / 5)
		n = n % 5
		if n in l:
			steps += 1
			n = 0
	print(steps)


n = int(input())
con = n // 5
if n % 5 > 0:
	con += 1
print(con)


count = 0

def fun(x):
	global count
	if x >= 5:
		a = int(x / 5)
		b = x % 5
		count = a
		if b == 0:
			print(count)
		else:
			fun(b)
	elif x >= 4 and x < 5:
		a = int(x / 4)
		b = x % 4
		count = count + a
		if b == 0:
			print(count)
		else:
			fun(b)
	elif x >= 3 and x < 4:
		a = int(x / 3)
		b = x % 3
		count = count + a
		if b == 0:
			print(count)
		else:
			fun(b)
	elif x >= 2 and x < 3:
		a = int(x / 2)
		b = x % 2
		count = count + a
		if b == 0:
			print(count)
		else:
			fun(b)
	elif x >= 1 and x < 2:
		a = int(x / 1)
		b = x % 1
		count = count + a
		if b == 0:
			print(count)
		else:
			fun(b)
k = int(input())
fun(k)


steps = int(input())
rem = steps // 5
if steps % 5 == 0:
	print(rem)
else:
	print(rem + 1)


a = int(input())
count = 1
while a > 5:
	a -= 5
	count += 1
print(count)


i = int(input())
if i == 1 or i == 2 or i == 3 or (i == 4):
	print(1)
elif i % 5 == 0:
	print(int(i / 5))
else:
	print(int(i / 5 + 1))


x = int(input())
rem = x % 5
ques = x // 5
if rem == 0:
	print(ques)
else:
	print(ques + 1)


n = int(input())
c = n // 5
n %= 5
c += n // 4
n %= 4
c += n // 3
n %= 3
c += n // 2
n %= 2
c += n
print(c)


x = int(input())
num = 0
while x - 5 >= 0:
	num += 1
	x = x - 5
while x - 4 >= 0:
	num += 1
	x = x - 4
while x - 3 >= 0:
	num += 1
	x = x - 3
while x - 2 >= 0:
	num += 1
	x = x - 2
while x - 1 >= 0:
	num += 1
	x = x - 1
print(num)


x = int(input())
print(str((x + 4) // 5))


v = int(input())
passos = 0
if v >= 5:
	passos += int(v / 5)
	v = v % 5
if v >= 4:
	passos += int(v / 4)
	v = v % 4
if v >= 3:
	passos += int(v / 3)
	v = v % 3
if v >= 2:
	passos += int(v / 2)
	v = v % 2
if v >= 1:
	passos += int(v / 1)
	v = v % 1
print(passos)


x = int(input())
a = int(x / 5)
left = x % 5
b = int(left / 4)
left = left % 4
c = int(left / 3)
left = left % 3
d = int(left / 2)
e = left % 2
print(a + b + c + d + e)


n = int(input())
a = 5
r = n // a
if n % a == 0:
	print(r)
else:
	print(r + 1)


s = 0
a = 0
r = 0
x = int(input())
if x < 5:
	s = 1
else:
	a = x // 5
	s = a
	r = x % 5
	if r != 0:
		s = s + 1
print(s)


try:
	k = int(input())
	(a, b, c, d, e) = (5, 4, 3, 2, 1)
	cn = 0
	while k >= a:
		k = k - a
		cn += 1
	while k >= b:
		k = k - b
		cn += 1
	while k >= c:
		k = k - c
		cn += 1
	while k >= d:
		k = k - d
		cn += 1
	while k >= e:
		k = k - e
		cn += 1
	print(cn)
except:
	pass


line = input()
a = int(line.split(' ')[0])
count = 0
while a != 0:
	if a >= 5:
		a -= 5
		count += 1
	elif a >= 4:
		a -= 4
		count += 1
	elif a >= 3:
		a -= 3
		count += 1
	elif a >= 2:
		a -= 2
		count += 1
	elif a >= 1:
		a -= 1
		count += 1
print(count)


steps = [5, 4, 3, 2, 1]
count = 0
friend = int(input())
for i in steps:
	if friend > 0:
		count += friend // i
		friend = friend % i
print(count)


n = input()
n = int(n)
ans = 0
ans = ans + n // 5
n = n % 5
ans = ans + n // 4
n = n % 4
ans = ans + n // 3
n = n % 3
ans = ans + n // 2
n = n % 2
ans = ans + n // 1
n = n % 1
print(ans)


n = int(input())
arr = [5, 4, 3, 2, 1]
counter = 0
while n > 0 and len(arr) > 0:
	if n - arr[0] >= 0:
		n = n - arr[0]
		counter += 1
	else:
		arr = arr[1:]
print(counter)


n = int(input())
a = [5, 4, 3, 2, 1]
res = 0
for i in a:
	if n > 0:
		res += n // i
		n = n % i
print(res)


n = int(input())
res = 0
for i in range(5, 0, -1):
	res += n // i
	n = n % i
print(res)


x = int(input())
y = 0
while x > 0:
	while x >= 5:
		x -= 5
		y += 1
	while x >= 4:
		x -= 4
		y += 1
	while x >= 3:
		x -= 3
		y += 1
	while x >= 2:
		x -= 2
		y += 1
	while x >= 1:
		x -= 1
		y += 1
print(y)


n = int(input())
t = n // 5
print([t + 1, t][n == 5 * t])


x = int(input())
cev = x // 5
if x % 5 != 0:
	cev += 1
print(cev)


n = int(input())
arr = (5, 4, 3, 2, 1)
count = 0
while n > 0:
	for i in arr:
		if n >= i:
			count += 1
			n -= i
			break
print(count)


from sys import stdin

def sol(num):
	li = [5, 4, 3, 2, 1]
	steps = 0
	for i in li:
		z = num // i
		steps += z
		num -= z * i
		if num == 0:
			return steps
number = int(stdin.readline())
print(sol(number))


a = int(input())
c = 0
b = a // 5
c = a % 5
if c > 0:
	if c <= 5:
		c = 1
	else:
		c = 2
print(b + c)


def main():
	i = 0
	y = 5
	x = int(input())
	if x <= 5:
		print(1)
	elif x % 5 == 0:
		q = 0
		while x != 0:
			x -= 5
			q += 1
		print(q)
	else:
		while x >= y:
			x -= y
			i += 1
			if x < y:
				5 - 1
				i += 1
		print(i)
main()


c = 0
x = int(input())
for i in range(x):
	if x > 5:
		x -= 5
		c += 1
	else:
		c += 1
		break
print(c)


sh = int(input())
n = 0
if sh <= 5:
	n += 1
	print(n)
else:
	n += sh // 5
	sh = sh % 5
	n += sh // 4
	sh = sh % 4
	n += sh // 3
	sh = sh % 3
	n += sh // 2
	sh = sh % 2
	n += sh // 1
	sh = sh % 1
	print(n)


x = int(input())
step = 0
while True:
	if x == 0:
		print(step)
		break
	step += x // 5
	x %= 5
	step += x // 4
	x %= 4
	step += x // 3
	x %= 3
	step += x // 2
	x %= 2
	step += x // 1
	x %= 1


m = int(input())
if m <= 5:
	print('1')
elif m % 5 == 0:
	print(m // 5)
else:
	k = m // 5 + 1
	print(k)


n = int(input())
count = 0
k = n // 5
m = n - k * 5
count += k
if m == 2 or m == 3 or m == 4:
	count += 1
else:
	k1 = m // 4
	m1 = m - k1 * 4
	count += k1
	if m1 == 2 or m1 == 3:
		count += 1
	else:
		k2 = m1 // 3
		m2 = m1 - k2 * 3
		count += k2
		if m2 == 2:
			count += 1
		else:
			k3 = m2 // 2
			m3 = m2 - k3 * 2
			count += k3
			if m3 == 1:
				count += 1
print(count)


n = int(input())
c = 0
for i in range(1, 6)[::-1]:
	c += n // i
	n = n % i
print(c)


n = int(input())
k = 0
if n % 5 == 0:
	k = -1
k += 1
print(n // 5 + k)


n = int(input())
f = 1
c = 0
if n <= 5:
	f = 0
else:
	r = n // 5
	e = n % 5
	if e > 0 and e <= 4:
		c = 1
if f == 0:
	print(1)
else:
	print(r + c)


x = int(input())
c = 0
c1 = 0
c2 = 0
c3 = 0
c4 = 0
while x >= 5:
	x = x - 5
	c = c + 1
while x == 4:
	x = x - 4
	c1 = c1 + 1
while x == 3:
	x = x - 3
	c2 = c2 + 1
while x == 2:
	x = x - 2
	c3 = c3 + 1
while x == 1:
	x = x - 1
	c4 = c4 + 1
print(c + c1 + c2 + c3 + c4)


l = [5, 4, 3, 2, 1]
n = int(input())
(i, steps) = (0, 0)
while n:
	if n >= l[i]:
		steps += n // l[i]
		n %= l[i]
	i += 1
print(steps)


x = int(input())
passos = 0
while x > 0:
	x = x - 5
	passos += 1
print(passos)


n = int(input())
count = 0
i = 5
while n != 0:
	count += n // i
	n %= i
	i -= 1
print(count)


n = int(input())
step = 0
while n >= 5:
	step = step + 1
	n = n - 5
if n != 0:
	print(step + 1)
else:
	print(step)


friend_x = int(input())
result = int(friend_x / 5)
if friend_x % 5 != 0:
	result = result + 1
print(result)


import math
x = float(input())
y1 = x / 1
y2 = x / 2
y3 = x / 3
y4 = x / 4
y5 = x / 5
s = min(y1, y2, y3, y4, y5)
print(math.ceil(s))


n = int(input())
c = 0
if n >= 5:
	c += n // 5
	n = n % 5
if n >= 4:
	c += n // 4
	n = n % 4
if n >= 3:
	c += n // 3
	n = n % 3
if n >= 2:
	c += n // 2
	n = n % 2
if n >= 1:
	c += n // 1
	n = n % 1
print(c)


x = int(input())
a = [1, 2, 3, 4, 5]
steps = 0
if x in a:
	steps += 1
	print(steps)
else:
	while x > max(a):
		x -= max(a)
		steps += 1
	if x in a:
		steps += 1
		print(steps)


n = int(input())
ans = 0
for i in range(5, 0, -1):
	ans += n // i
	n %= i
print(ans)


n = int(input())
count = 0
while n:
	if n > 5:
		n -= 5
		count += 1
	else:
		count += 1
		break
print(count)


x = int(input())
valid_steps = [1, 2, 3, 4, 5]
pos = 0
count_steps = 0
i = 4
while pos <= x:
	if x - pos >= valid_steps[i]:
		pos += valid_steps[i]
		count_steps += 1
	else:
		if i < 0:
			break
		i -= 1
print(count_steps)


print(-(-int(input()) // 5))


def main():
	i = int(input())
	a = 5
	p = 0
	while i > 0:
		if i >= a:
			i -= a
			p += 1
		else:
			a -= 1
	print(p)
main()


n = int(input())
A = n // 5
a = n % 5
B = a // 4
b = a % 4
C = b // 3
c = b % 3
D = c // 2
d = c % 2
N = A + B + C + D + d
print(N)


n = int(input())
fives = n // 5
n %= 5
fours = n // 4
n %= 4
three = n // 3
n %= 3
two = n // 2
n %= 2
print(fives + three + fours + two + n)


import functools
import logging
import os
import sys
import time
logger = logging.getLogger()
reader = sys.stdin
is_judge = os.getenv('DEBUGGING') is None

def timeit(func):

	@functools.wraps(func)
	def timed(*args, **kwargs):
		if is_judge:
			rv = func(*args, **kwargs)
		else:
			ts = time.time()
			rv = func(*args, **kwargs)
			te = time.time()
			logger.debug('performance %r %2.2fms', func.__name__, (te - ts) * 1000)
		return rv
	return timed

@timeit
def main():
	n = int(reader.readline())
	print(n // 5 + min(n % 5, 1))

def setup():
	global logger, reader
	if is_judge:
		logger.setLevel(logging.WARNING)
	else:
		handler = logging.StreamHandler(sys.stdout)
		handler.setLevel(logging.DEBUG)
		formatter = logging.Formatter('{asctime}s - {message}', style='{')
		handler.setFormatter(formatter)
		logger.addHandler(handler)
		logger.setLevel(logging.DEBUG)
		reader = open('input.txt')
setup()
try:
	main()
except KeyboardInterrupt:
	logger.debug('KeyboardInterrupt')
except IOError as e:
	logger.error(f'I/O error({e.errno}): {e.strerror}')


n = int(input())
step5 = n // 5
n = n % 5
step4 = n // 4
n = n % 4
step3 = n // 3
n = n % 3
step2 = n // 2
n = n % 2
step1 = n
print(step5 + step4 + step3 + step2 + step1)


x = int(input())
y = 0
while x > 5:
	x = x - 5
	y = y + 1
y = y + 1
print(y)


n = int(input())
if n > 4:
	r = 0 if n % 5 == 0 else 1
	r += n // 5
	print(r)
else:
	print(1)


import sys
input = sys.stdin.readline

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

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
import math
n = inp()
print(math.ceil(n / 5))


n = int(input())
s = 0
s += -(-n // 5)
print(s)


x = int(input())
nearest_5 = x % 5
nearest_5 = x - nearest_5
total = 0
if x <= 5:
	print('1')
elif x % 5 == 0:
	print(x // 5)
else:
	total = nearest_5 / 5 + 1
	print(int(total))


n = int(input())
cost = n // 5
if n % 5 > 0:
	cost += 1
print(cost)


n = int(input())
val = [5, 4, 3, 2, 1]
x = 0
for i in val:
	x += n // i
	n = n % i
print(x)


from math import ceil
friendsLocation = int(input())
friendsLocation = float(friendsLocation)
print(ceil(friendsLocation / 5))


a = int(input())
co = a // 5
if a % 5 != 0:
	co += 1
print(co)


x = int(input())
n5 = x // 5
n4 = (x - 5 * n5) // 4
n3 = (x - 5 * n5 - 4 * n4) // 3
n2 = (x - 5 * n5 - 4 * n4 - 3 * n3) // 2
n1 = x - 5 * n5 - 4 * n4 - 3 * n3 - 2 * n2
print(n5 + n4 + n3 + n2 + n1)


import math
numbers = list(map(int, input().split()))
n = numbers[0]
j = math.floor(n / 5)
if n % 5 == 0:
	print(j)
else:
	print(j + 1)


import math
x = int(input())
steps = math.ceil(x / 5)
print(steps)


a = int(input())
step = 0
step += a // 5
a = a % 5
step += a // 4
a = a % 4
step += a // 3
a = a % 3
step += a // 2
a = a % 2
step += a // 1
a = a % 1
print(step)


a = int(input())
p = [5, 4, 3, 2, 1]
count = 0
while a > 0:
	for q in p:
		if a >= q:
			count += 1
			a -= q
			break
print(count)


displace = int(input())
if displace % 5 == 0:
	print(int(displace / 5))
else:
	print(displace // 5 + 1)


distancia = int(input())
if distancia % 5 == 0:
	pasos = distancia // 5
else:
	pasos = distancia // 5 + 1
print(pasos)


n = int(input())
m = 0
for i in range(5, 0, -1):
	if i <= n:
		m += n // i
	n = n % i
print(m)


distance = int(input(''))
multiple = int(distance / 5)
remainder = distance % 5
if distance <= 5:
	print(1)
elif distance <= 10:
	print(2)
elif remainder == 0:
	print(multiple)
else:
	print(multiple + 1)


d = int(input())
l = 0
while l * 5 < d:
	l = l + 1
print(l)


import math

def Elephant():
	x = int(input())
	p = 0
	if x % 5 == 0:
		p = int(x / 5)
	else:
		p = math.floor(x / 5) + 1
	return int(p)
print(Elephant())


n = int(input())
l = [1, 2, 3, 4, 5]
k = 0
if n in l:
	print(1)
else:
	k = n // 5
	p = n % 5
	if p in l:
		k = k + 1
	print(k)


cord = int(input())
if cord % 5 == 0:
	print(cord // 5)
else:
	print(cord // 5 + 1)


n = int(input())
mod = n % 5 != 0
print(n // 5 + mod)


n = int(input())
k = 0
for e in [5, 4, 3, 2, 1]:
	k += n // e
	n = n % e
print(k)


n = int(input())
t = 0
t = t + n // 5
n = n % 5
if n != 0:
	t = t + 1
print(t)


a = input()
a = int(a)
if a in [1, 2, 3, 4, 5]:
	print(1)
else:
	f = 0
	pos = 0
	while True:
		if f >= a:
			break
		f = f + 5
		pos += 1
	print(pos)


number = int(input())
one = 0
two = 0
three = 0
four = 0
five = number // 5
remainder = number % 5
if remainder % 4 == 0:
	four = remainder // 4
elif remainder % 3 == 0:
	three = remainder // 3
elif remainder % 2 == 0:
	two = remainder // 2
elif remainder % 1 == 0:
	one = remainder // 1
print(one + two + three + four + five)


a = int(input())
o = a // 5
if a % 5 != 0:
	o += 1
print(o)


def A617(position):
	steps = int(position / 5)
	if position % 5 > 0:
		steps = steps + 1
	return steps
number = int(input())
result = A617(number)
print(result)


distance = int(input())
result = 0
for i in range(5, 0, -1):
	steps = distance // i
	result += steps
	distance -= steps * i
print(result)


budget = int(input())
if budget % 5 == 0:
	print(int(budget / 5))
else:
	print(int(budget // 5 + 1))


def solve(x: int) -> int:
	if x % 5 >= 1:
		return x // 5 + 1
	else:
		return x // 5
print(solve(int(input())))


n = int(input(''))
count = 0
set_co = [1, 2, 3, 4, 5]
while n > 0:
	for i in set_co:
		if n == i:
			count += 1
			n = n - i
	if n > 5:
		n = n - 5
		count += 1
print(count)


def process(n):
	l = [5, 4, 3, 2, 1]
	x = 0
	while n > 0:
		for i in l:
			if n - i >= 0:
				n = n - i
				x += 1
				break
	return x
f = [int(x) for x in input().split()]
ans = process(f[0])
print(ans)


X = int(input())
C = 0
while X != 0:
	if X - 5 >= 0:
		C += 1
		X -= 5
	elif X - 4 >= 0:
		C += 1
		X -= 4
	elif X - 3 >= 0:
		C += 1
		X -= 3
	elif X - 2 >= 0:
		C += 1
		X -= 2
	elif X - 1 >= 0:
		C += 1
		X -= 1
print(C)


x = int(input())
print((x + 4) // 5)
8


import math

def minSteps(n):
	return math.ceil(n / 5)
print(minSteps(int(input())))


def minMoves(distance):
	step = 0
	for i in [5, 4, 3, 2, 1]:
		temp = distance % i
		step += (distance - temp) // i
		distance = temp
		if distance == 0:
			break
	return step
d = int(input())
print(minMoves(d))


a = int(input())
result = int(a / 5)
if a == result * 5:
	print(result)
else:
	print(result + 1)


x = int(input())
arr = [5, 4, 3, 2, 1]
ans = 0
for distance in arr:
	if distance <= x:
		steps = (x - x % distance) // distance
		ans += steps
		x -= distance * steps
print(ans)


from sys import stdin, maxsize
from math import ceil
(lines, line_index) = (stdin.readlines(), -1)

def get_line():
	global lines, line_index
	line_index += 1
	return lines[line_index]

def main():
	x = int(get_line())
	nums = [5, 4, 3, 2, 1]
	steps = 0
	for i in range(len(nums)):
		if x == 0:
			break
		steps += x // nums[i]
		x = x % nums[i]
	print(steps)
main()


def elephant(friend_house):
	if friend_house % 5 != 0:
		print(friend_house // 5 + 1)
	else:
		print(friend_house // 5)
friend_house = int(input())
elephant(friend_house)


n = int(input())
answer = n // 5
if n % 5 != 0:
	answer += 1
print(answer)


destination = int(input())
steps = [1, 2, 3, 4, 5]
(current, count) = (0, 0)
while current != destination:
	if current + steps[-1] <= destination:
		current += steps[-1]
	else:
		i = -2
		while current + steps[i] > destination:
			i -= 1
		current += steps[i]
	count += 1
print(count)


a = int(input())
cou = a // 5
if a % 5 == 0:
	print(cou)
else:
	print(cou + 1)


n = int(input())
if n < 5:
	print('1')
else:
	if n % 5 == 0:
		c = n / 5
	elif n > 5 and n % 5 != 0:
		c = n / 5 + 1
	print(int(c))


x = int(input())
s = 0
flag = 0
for i in range(x):
	s = s + 5
	flag += 1
	if s >= x:
		print(flag)
		break


x = int(input())
if x <= 5:
	print(1)
elif x % 5 == 0:
	print(x // 5)
elif x > 5 and x % 5 != 0:
	print(x // 5 + 1)


n = int(input())
a = [5, 4, 3, 2, 1]
c = 0
for i in range(5):
	if n >= a[i]:
		c += n // a[i]
		n = n % a[i]
		if n == 0:
			break
print(c)


n = int(input())
ost = n % 5
r = (n - ost) / 5
if ost > 0:
	r += 1
print(int(r))


x = int(input())
if x % 5 != 0:
	y = x // 5 + 1
else:
	y = x // 5
print(y)


location = int(input())
ste = [1, 2, 3, 4, 5]
x = 0
elephant = 0
while True:
	if location > elephant:
		elephant = elephant + max(ste)
		x += 1
	elif elephant > location:
		sum = elephant - location
		elephant = elephant - sum
	elif elephant == location:
		print(x)
		break


n = int(input())
s = [5, 4, 3, 2, 1]
c = 0
for i in range(0, 5):
	c = c + n // s[i]
	n = n % s[i]
print(c)


n = int(input())
step = 0
l = [1, 2, 3, 4, 5]
while n != 0:
	if n in l:
		step += 1
		break
	n = n - 5
	step += 1
print(step)


distance = int(input())
step = 0
while distance >= 5:
	distance = distance - 5
	step += 1
if distance == 0:
	print(step)
else:
	print(step + 1)


d = int(input())
c = 0
while d > 0:
	if d - 5 >= 0:
		d = d - 5
		c = c + 1
	elif d - 4 >= 0:
		d = d - 4
		c = c + 1
	elif d - 3 >= 0:
		d = d - 3
		c = c + 1
	elif d - 2 >= 0:
		d = d - 2
		c = c + 1
	else:
		d = d - 1
		c = c + 1
print(c)


n = int(input())
while True:
	if n > 0 and n % 5 != 0:
		m = n // 5 + 1
	else:
		m = n // 5
	print(m)
	break


x = int(input())
count = 0
for i in range(100000000):
	if x - 50000 >= 0:
		x = x - 50000
		count = count + 10000
		continue
	if x - 5 >= 0:
		x = x - 5
		count = count + 1
		continue
	elif x - 4 >= 0:
		x = x - 4
		count = count + 1
		continue
	elif x - 3 >= 0:
		x = x - 3
		count = count + 1
		continue
	elif x - 2 >= 0:
		x = x - 2
		count = count + 1
		continue
	elif x - 1 >= 0:
		x = x - 1
		count = count + 1
		continue
	if x == 0:
		break
print(count)


n = int(input())
i = 1
while n > 5:
	n = n - 5
	i = i + 1
print(i)


n = int(input())
m = 0
for i in range(n, n + 10):
	if i % 5 == 0:
		m = i
		break
print(int(m / 5))


x = int(input())
arr1 = [5, 4, 3, 2, 1]
c = 0
while x > 0:
	a = max(arr1)
	if a <= x:
		x -= a
		c += 1
	else:
		arr1.remove(a)
print(c)


x = int(input())
if x % 5:
	print(int(x / 5) + 1)
else:
	print(int(x / 5))


x = int(input())
print(x // 5 + bool(x % 5))


x = int(input())
l = [5, 4, 3, 2, 1]
a = 0
for i in range(len(l)):
	if l[i] <= x:
		a = a + int(x / l[i])
		x = x % l[i]
print(a)


new = float(input())
div = new / 5
if div > int(div):
	print(int(div) + 1)
else:
	print(int(div))


a = int(input())
if a % 5 == 0:
	t = a / 5
if a % 5 != 0:
	t = a // 5 + 1
print(int(t))


distance = int(input())
p = 0
for i in range(5):
	k = distance // (5 - i)
	distance -= (5 - i) * k
	p += k
print(p)


steps = int(input())
num_of_setps = steps // 5
print(num_of_setps + int(steps % 5 > 0))


n = int(input())
count = n // 5
x = n % 5
ls = range(4, 0, -1)
if x == 0:
	print(str(n // 5))
else:
	for i in ls:
		if x % i == 0 and x >= i:
			print(str(count + x // i))
			break


num = int(input())
i = num // 5
if num == i * 5:
	print(i)
else:
	print(i + 1)


def num_five(a):
	a = x // 5
	b = int(x % 5)
	return (a, b)
x = int(input())
if x > 5 and x % 5 == 0:
	result = num_five(x)
	print(result[0])
elif x > 5 and x % 5 != 0:
	result = num_five(x)
	print(result[0] + 1)
else:
	print('1')


test = int(input())
testing_array = []
for i in range(1, 6):
	if i <= test:
		divided = test // i
		remainder = test % i
		if remainder:
			first = 5
			while first >= 1:
				rem_result = remainder % first
				if not rem_result:
					rem_result = remainder / first
					result = int(divided + rem_result)
					testing_array.append(result)
					break
				first -= 1
		else:
			testing_array.append(divided)
print(min(testing_array))


x = int(input())
count = 0
i = 5
while x > 0:
	while i <= 5 and i > 0:
		while x >= i:
			x = x - i
			count += 1
		i -= 1
	break
print(count)


steps = int(input())
counter = 0
counter += int(steps / 5)
steps -= counter * 5
while steps > 0:
	if steps >= 4:
		steps -= 4
		counter += 1
		continue
	if steps >= 3:
		steps -= 3
		counter += 1
		continue
	if steps >= 2:
		steps -= 2
		counter += 1
		continue
	if steps >= 1:
		steps -= 1
		counter += 1
print(counter)


x = int(input())
answer = x // 5
x = x - 5 * (x // 5)
print(answer + 1 if x > 0 else answer)


x = int(input(''))
a = int(x / 5)
b = int(x % 5)
c = int(b / 4)
d = int(b % 4)
e = int(d / 3)
f = int(d % 3)
g = int(f / 2)
h = int(f % 2)
i = int(h / 1)
j = a + c + e + g + i
print(j)


x = int(input())
s = 0
while x != 0:
	x -= max(list(filter(lambda a: a <= x, [1, 2, 3, 4, 5])))
	s += 1
print(s)


x = int(input())
dis = int(x / 5)
final_result = dis
if x % 5 != 0:
	final_result = final_result + 1
print(final_result)


a = int(input())
c = 0
k = 0
while c < a:
	c += 5
	k += 1
print(k)


hmome = int(input())
if hmome % 5 == 0:
	print(hmome // 5)
else:
	print(hmome // 5 + 1)


import math
read = int(input())
sumt = 0
for x in range(5, 1, -1):
	sumt = sumt + read / x
	read = read - read / x * x
print(math.ceil(sumt))


n = int(input())
a = [5, 4, 3, 2, 1]
k = len(a)
count = 0
for i in range(k):
	b = n // a[i]
	if b > 0:
		count += n // a[i]
		n = n % a[i]
print(count)


x = int(input())
step = 0
a = x // 5
b = (x - a * 5) // 4
c = (x - a * 5 - b * 4) // 3
d = (x - a * 5 - b * 4 - c * 3) // 2
e = x - a * 5 - b * 4 - c * 3 - d * 2
step = a + b + c + d + e
print(step)


aaa = int(input())
print(-(-aaa // 5))


import sys
import math
x = int(sys.stdin.readline())
print(math.ceil(x / 5))


i = input()
i = int(i)
v = (i + 4) // 5
print(str(v))


n = int(input())
steps = 0
while True:
	if n >= 5:
		steps += 1
		n -= 5
	elif n < 5 and n > 0:
		steps += 1
		break
	else:
		break
print(steps)


origin = 0
x = int(input())
count = 0
for steps in range(origin, x, 5):
	count += 1
print(count)


def Elephant():
	x = int(input())
	i = steps = 0
	tmp = [j for j in range(1, 6) if x // j > 0]
	stepsize = max(tmp)
	while i < x:
		steps += (x - i) // stepsize
		i += stepsize * steps
		tmp2 = [j for j in range(1, stepsize) if (x - i) // j > 0]
		try:
			stepsize = max(tmp2)
		except:
			continue
	print(steps)
	return None

def main():
	Elephant()
main()


n = int(input())
count = 0
for i in range(5, 1, -1):
	while n / i > 0:
		count += 1
		n -= i
print(count)


s = int(input())
c = 0
wu = s // 5
if s % 5 == 0:
	print(wu)
else:
	yu = (s - 5 * wu) // (s % 5)
	print(wu + yu)


count = 0
coord = int(input())
for x in range(5, 0, -1):
	count += coord // x
	coord -= coord // x * x
print(count)


import sys
x = int(sys.stdin.readline().split()[0])
total_steps = 0
steps = [0 for i in range(5)]
i = 5
while i >= 1:
	steps[i - 1] = int(x / i)
	x = x - steps[i - 1] * i
	total_steps += steps[i - 1]
	if x <= 0:
		break
	i -= 1
print(total_steps)


loc = int(input())
steps = 0
for i in [5, 4, 3, 2, 1]:
	if loc == 0:
		break
	for j in range(int(loc / i)):
		loc = loc - i
		steps = steps + 1
print(steps)


a = int(input())
count = 0
k = 5
while a > 0:
	a -= k
	count += 1
print(count)


n = int(input())
counter = n // 5
n %= 5
counter += n // 4
n %= 4
counter += n // 3
n %= 3
counter += n // 2
n %= 2
counter += n
print(counter)


inp = int(input())
count = 0
if 0 < inp < 5:
	count += 1
else:
	while inp >= 5:
		inp -= 5
		count += 1
		if inp == 5:
			count += 0
		elif 0 < inp < 5:
			count += 1
print(count)


x = int(input())
steps = 0
while x > 0:
	steps += x // 5
	x %= 5
	steps += x // 4
	x %= 4
	steps += x // 3
	x %= 3
	steps += x // 2
	x %= 2
	steps += x
	x = 0
print(steps)


x = int(input())
fiveCount = 0
fourCount = 0
threeCount = 0
twoCount = 0
oneCount = 0
while x >= 5:
	x = x - 5
	fiveCount += 1
else:
	while x >= 4:
		x = x - 4
		fourCount += 1
	else:
		while x >= 3:
			x = x - 3
			threeCount += 1
		else:
			while x >= 2:
				x = x - 2
				twoCount += 1
			else:
				while x >= 1:
					x = x - 1
					oneCount += 1
				else:
					None
y = fiveCount + fourCount + threeCount + twoCount + oneCount
print(y)


distance = input()
d = int(distance)
if d <= 5:
	print('1')
elif d % 5 == 0:
	res = d // 5
	print(res)
else:
	res = d // 5 + 1
	print(res)


x = int(input())
ans = 0
if x % 5 == 0:
	pass
elif x % 5 == 1:
	ans += 1
	x -= 1
elif x % 5 == 2:
	ans += 1
	x -= 2
elif x % 5 == 3:
	ans += 1
	x -= 3
elif x % 5 == 4:
	ans += 1
	x -= 4
ans += x // 5
print(str(ans))


import sys
from math import log

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
fast_reader = sys.stdin.readline
fast_writer = sys.stdout.write

def input():
	return fast_reader().strip()

def print(*argv):
	fast_writer(' '.join((str(i) for i in argv)))
	fast_writer('\n')
n = int(input())
ans = 0
for i in range(5, 0, -1):
	ans += n // i
	n = n % i
print(ans)


k = input()
print((int(k) - 1) // 5 + 1)


c = 0

def f(num, s):
	while num >= s:
		num -= s
		global c
		c += 1
	return num
n = int(input())
while n:
	n = f(n, 5)
	n = f(n, 4)
	n = f(n, 3)
	n = f(n, 2)
	n = f(n, 1)
print(c)


X = int(input())
if X % 5 is 0:
	R = X // 5
else:
	R = X // 5 + int(X % 5 < 6)
print(R)


y = int(input())
s = 0
s = s + y // 5
y = y % 5
s = s + y // 4
y = y % 4
s = s + y // 3
y = y % 3
s = s + y // 2
y = y % 2
s = s + y // 1
y = y % 1
print(s)


N = int(input())
M = N / 5
if M == int(N / 5):
	print(int(N / 5))
else:
	print(int(N / 5) + 1)


n = int(input())
l = [1, 2, 3, 4, 5]
if n < 6:
	print(1)
	exit()
ans = 0
while n != 0:
	if n >= 5:
		ans = ans + n // 5
		n = n % 5
		continue
	if n >= 4:
		ans = ans + n // 4
		n = n % 4
		continue
	if n >= 3:
		ans = ans + n // 3
		n = n % 3
		continue
	if n >= 2:
		ans = ans + n // 2
		n = n % 2
		continue
	if n >= 1:
		ans = ans + n
		n = 0
print(ans)


coord = int(input())
counter = 0
while coord > 0:
	if coord >= 5:
		inc = coord // 5
		counter += inc
		coord -= 5 * inc
		continue
	if coord >= 4:
		inc = coord // 4
		counter += inc
		coord -= 4 * inc
		continue
	if coord >= 3:
		inc = coord // 3
		counter += inc
		coord -= 3 * inc
		continue
	if coord >= 2:
		inc = coord // 2
		counter += inc
		coord -= 2 * inc
		continue
	if coord >= 1:
		inc = coord // 1
		counter += inc
		coord -= 1 * inc
		continue
print(counter)


X = int(input())
print(X // 5 + int(X % 5 > 0))


x = int(input())
s = 0
while x > 0:
	s = s + x // 5
	x = x % 5
	s = s + x // 4
	x = x % 4
	s = s + x // 3
	x = x % 3
	s = s + x // 2
	x = x % 2
	s = s + x // 1
	x = x % 1
print(s)


li = [1, 2, 3, 4, 5]
n = int(input())
c = 0
while True:
	if n in li:
		c += 1
		print(c)
		break
	else:
		n -= 5
		c += 1


n = int(input())
if n % 5 == 0:
	q = n // 5
	print(q)
else:
	q = n // 5
	print(q + 1)


x = int(input())
X = [5, 4, 3, 2, 1]
c = 0
for i in X:
	while x >= i:
		x = x - i
		c += 1
print(c)


x = int(input())
steps = 1
while True:
	if x > 5:
		x = x - 5
		steps = steps + 1
	else:
		break
print(steps)


x = int(input())
p = x // 5
if x % 5 != 0:
	p += 1
print(p)


def distance_house(x):
	count = 0
	while x >= 5:
		x = x - 5
		count += 1
	if x > 0:
		count += 1
	return count
distance = input()
print(distance_house(int(distance)))


a = int(input())
sum = 0
for i in range(5, 0, -1):
	k = a // i
	a -= k * i
	sum += k
print(sum)


n = int(input())
s = [5, 4, 3, 2, 1]
p = 0
for i in range(len(s)):
	if n >= s[i]:
		p += n // s[i]
		n = n % s[i]
print(p)


n = int(input())
lst = [5, 4, 3, 2, 1]
dis = 0
count = 0
for i in range(0, n):
	if dis == n:
		break
	else:
		for j in range(0, 5):
			if dis + lst[j] > n:
				continue
			else:
				dis += lst[j]
				count += 1
				break
print(count)


x = int(input())
l = [5, 4, 3, 2, 1]
i = 0
while x > 0:
	if l[0] <= x:
		x -= l[0]
		i += 1
	else:
		l.pop(0)
print(i)


n = int(input())
steps = 0
for i in range(5, 0, -1):
	(curr, rem) = divmod(n, i)
	steps += curr
	n -= curr * i
	curr = rem
	if rem == 0:
		break
print(steps)


n = int(input())
step = 1
while n > 5:
	n -= 5
	step += 1
print(step)


import math
i = int(input())
print(math.ceil(i / 5.0))


x = int(input())
if x <= 5:
	print(1)
else:
	p = 5
	count_step = 1
	while p != x:
		if len([k for k in range(1, 6) if p + k == x]) > 0:
			print(count_step + 1)
			exit()
		else:
			p += 5
			count_step += 1
	print(count_step)


m = int(input())
float
n = 0
if m >= 5:
	n = n + m / 5
	m = m % 5
if m >= 4:
	n = n + m / 4
	m = m % 4
if m >= 3:
	n = n + m / 3
	m = m % 3
if m >= 2:
	n = n + m / 2
	m = m % 2
if m >= 1:
	n = n + m / 1
	m = m % 1
print(int(n))


a = int(input())
count = 1
while True:
	if a > 5:
		a = a - 5
		count += 1
	else:
		break
print(count)


n = int(input())
e = [5, 4, 3, 2, 1]
if n in e:
	print(1)
else:
	cnt = 0
	for li in e:
		cnt += n // li
		n %= li
	print(cnt)


n = int(input())
k = n % 5
if n <= 5:
	print(1)
elif k == 0:
	print(n // 5)
else:
	print(n // 5 + 1)


n = int(input())
k5 = n // 5
ost = n % 5
k4 = ost // 4
ost = ost % 4
k3 = ost // 3
ost = ost % 3
k2 = ost // 2
ost = ost % 2
k1 = ost // 1
print(k5 + k4 + k3 + k2 + k1)


n = int(input())
if n <= 5:
	print(n // n)
elif n % 5 == 0:
	print(n // 5)
else:
	mod = n % 5
	print((n - mod) // 5 + 1)


def elephant(x):
	count = 0
	n = x
	for i in range(5, 0, -1):
		count += n // i
		n = n % i
	print(count)
x = int(input())
elephant(x)


n = int(input())
if n <= 5:
	print(1)
	exit()
s = 0
while n != 0:
	if n >= 5:
		s += 1
		n -= 5
	if n == 4 or n == 3 or n == 2 or (n == 1):
		s += 1
		n = 0
print(s)


n = int(input())
t = n // 5
n = n % 5
t = t + n // 4
n = n % 4
t = t + n // 3
n = n % 3
t = t + n // 2
n = n % 2
t = t + n // 1
print(t)


n = int(input())
num = 0
while n > 4:
	num += 1
	n -= 5
if n != 0:
	num += 1
print(num)


step_lengths = range(1, 6)[::-1]
x = int(input())
counter = 0
for step in step_lengths:
	counter += int(x / step)
	x = x % step
print(counter)


def main():
	from sys import stdout
	n = int(input())
	res = n // 5
	if n % 5 != 0:
		res += 1
	stdout.write(str(int(res)))
main()


import math
a = int(input())
if a <= 5:
	print('1')
else:
	print(math.ceil(a / 5))


n = int(input())
sum = 0
if n != 0:
	sum = sum + int(n / 5)
	n = n % 5
if n != 0:
	sum = sum + int(n / 4)
	n = n % 4
if n != 0:
	sum = sum + int(n / 3)
	n = n % 3
if n != 0:
	sum = sum + int(n / 2)
	n = n % 2
if n != 0:
	sum = sum + int(n / 1)
	n = n % 1
print(sum)


st = input()
a = int(st)
if a % 5 == 0:
	print(a // 5)
else:
	print(a // 5 + 1)


x = int(input())
if x > 5:
	n = int(x / 5)
	mod = x % 5
	if mod > 0:
		print(n + 1)
	else:
		print(n)
else:
	print(1)


n = int(input())
sum = n // 5
if n % 5 != 0:
	sum += 1
print('{0}'.format(sum))


e = 0
n = int(input(''))
if n <= 5:
	val = 1
else:
	x = n // 5
	y = n % 5
	if y == 0:
		val = x
	else:
		val = x + 1
print(val)


x = int(input())
moveNumber = 0

def move(x):
	if x % 5 == 0:
		return int(x / 5)
	else:
		return int(x / 5) + 1
print(move(x))


c = int(input())
x = [5, 4, 3, 2, 1]
count = 0
while x != []:
	m = max(x)
	while c >= max(x):
		c = c - m
		count += 1
	x.pop(0)
print(count)


n = int(input())
l = [1, 2, 3, 4, 5]
count = 0
x = -1
while 1:
	if n >= l[x]:
		n = n - l[x]
		count = count + 1
	else:
		x = x - 1
	if n == 0:
		break
print(count)


num = int(input())
print(int(num / 5) if num % 5 == 0 else int(num / 5 + 1))


def getCeil(n):
	res = n // 5
	if n / 5 - res > 0:
		return res + 1
	else:
		return res
x = int(input())
print(getCeil(x))


x = int(input())
steps = [5, 4, 3, 2, 1]
no_of_steps = 0
for i in steps:
	if x // i == 0:
		continue
	elif x % i == 0:
		no_of_steps = no_of_steps + x // i
		break
	else:
		no_of_steps = no_of_steps + x // i
		x = x % i
print(no_of_steps)


import math

def main():
	x = int(input())
	c = 0
	num = 5
	while x > 0 and num > 0:
		if num <= x:
			c += math.floor(x / num)
			x %= num
		elif x % num != 0:
			num -= 1
		else:
			continue
	print(c)
main()


import math
friend = int(input())
steps = 9999999999999
for i in range(1, 6):
	steps_needed = friend / i
	if steps_needed < steps:
		steps = steps_needed
ans = math.ceil(steps)
print(ans)


x = int(input())
total_steps = 0
while x > 0:
	if x >= 5:
		r = x // 5
		total_steps += r
		x -= r * 5
	elif x >= 4:
		r = x // 4
		total_steps += r
		x -= r * 4
	elif x >= 3:
		r = x // 3
		total_steps += r
		x -= r * 3
	elif x >= 2:
		r = x // 2
		total_steps += r
		x -= r * 2
	else:
		total_steps += x
		x = 0
print(total_steps)


x = int(input())
step = 0
if x <= 5:
	step = 1
elif x % 5 == 0:
	step = int(x / 5)
else:
	first_5_step = int(x // 5)
	step = int(first_5_step + 1)
print(step)


x = int(input())
if x % 5 != 0:
	T = x // 5 + 1
	print(T)
else:
	S = x // 5
	print(S)


x = int(input())
s = [1, 2, 3, 4, 5]
c = 0
while x > 0:
	for i in range(5):
		c += x // s[4 - i]
		x %= s[4 - i]
print(c)


s = input()
count = 0
if int(s) % 5 == 0:
	count += int(s) // 5
	print(count)
else:
	count += int(s) // 5
	print(count + 1)


n = int(input())
b = n % 5
if b == 0:
	print(n // 5)
elif b <= 5:
	print(n // 5 + 1)


d = int(input())
l = 0
while True:
	l = l + 1
	g = l * 5
	if g >= d:
		print(l)
		break


pos = input()
max_steps = int(pos) / 5
(i, d) = divmod(max_steps, 1)
if d == 0:
	steps = i
else:
	steps = i + 1
print(int(steps))


m = int(input())
ans = m // 5
if m % 5 != 0:
	ans += 1
print(ans)


x = int(input())
f = 0
s = 0
if x == 0:
	print(0)
elif x == 1 or x == 2 or x == 3 or (x == 4) or (x == 5):
	print(1)
elif x > 5:
	while x >= 5:
		x -= 5
		s += 1
	if x > 0:
		s += 1
	print(s)


x = int(input())
k = 5
n = 0
while x != 0:
	if x % k != x:
		c = x // k
		x = x - c * k
		n = n + c
	else:
		k = k - 1
print(n)


x = int(input(''))
cnt = 0
while x >= 5:
	x -= 5
	cnt += 1
while x >= 4:
	x -= 4
	cnt += 1
while x >= 3:
	x -= 3
	cnt += 1
while x >= 2:
	x -= 2
	cnt += 1
while x >= 1:
	x -= 1
	cnt += 1
print(cnt)


n = int(input())
no_of_steps = 0
remainder = n % 5
if remainder == 0:
	no_of_steps = n / 5
else:
	no_of_steps = n / 5 + 1
print(int(no_of_steps))


a = int(input())
n = 0
if a >= 5:
	if a % 5 == 0:
		print(n + a // 5)
		a = 0
		exit
	else:
		n += a // 5
		a = a % 5
if a >= 4:
	if a % 4 == 0:
		print(n + a // 4)
		a = 0
		exit
	else:
		n += a // 4
		a = a % 4
if a >= 3:
	if a % 3 == 0:
		print(n + a // 3)
		a = 0
		exit
	else:
		n += a // 3
		a = a % 3
if a == 2:
	print(n + a // 2)
	a = 0
	exit
if a == 1:
	print(n + 1)


position = int(input())
p = position // 5
if position % 5 == 0:
	print(p)
else:
	print(p + 1)


x = int(input())
r = x % 5
if r == 0:
	k = x // 5
else:
	k = x // 5 + 1
print(k)


x = int(input())
c = 0
n = x
while x != 0:
	if x == 1 or x == 2 or x == 3 or (x == 4) or (x == 5):
		x = 0
		c += 1
	else:
		c = c + x // 5
		x = x % 5
print(c)


n = int(input())
steps = 0
if n >= 5:
	steps += n // 5
	n = n % 5
if n >= 4:
	steps += n // 4
	n = n % 4
if n >= 3:
	steps += n // 3
	n = n % 3
if n >= 2:
	steps += n // 2
	n = n % 2
else:
	steps += n
print(steps)


import itertools
y = int(input())
ks = y
for x in list(itertools.permutations([1, 2, 3, 4, 5], 5)):
	s = 0
	fy = y
	for i in x:
		s += fy // i
		fy = fy % i
	if fy == 0 and 0 < s <= ks:
		ks = s
print(ks)


dist = int(input())
moves = [5, 4, 3, 2, 1]
ans = 0
for move in moves:
	ans += dist // move
	dist %= move
print(ans)


import math
x = int(input())
if x % 5 == 0:
	y = math.floor(x / 5)
	print(y)
else:
	y = math.floor(x / 5)
	print(y + 1)


steps = int(input())
total = 0
while steps > 0:
	if steps >= 5:
		total += steps // 5
		steps -= 5 * (steps // 5)
	elif steps >= 4:
		total += steps // 4
		steps -= 4 * (steps // 4)
	elif steps >= 3:
		total += steps // 3
		steps -= 3 * (steps // 3)
	elif steps >= 2:
		total += steps // 2
		steps -= 2 * (steps // 2)
	else:
		total += steps
		steps -= steps
print(total)


n = int(input())
if n <= 5:
	print(1)
elif n % 5 == 0:
	print(n // 5)
else:
	z = n
	p = z // 5
	print(p + 1)


n = int(input())
moves = [5, 4, 3, 2, 1]
steps = 0
for i in moves:
	if n <= 0:
		break
	if n >= i:
		steps += n // i
		n %= i
print(steps)


x = int(input())
dist = 0
if x >= 5:
	n = x // 5
	x = x % 5
	dist = n
if x >= 4:
	n = x // 4
	x = x % 4
	dist = dist + n
if x >= 3:
	n = x // 3
	x = x % 3
	dist = dist + n
if x >= 2:
	n = x // 2
	x = x % 2
	dist = dist + n
dist = dist + x
print(dist)


def steps(x):
	min = 3
	if x <= 5:
		print(1)
	elif x % 5 == 0:
		print(x // 5)
	else:
		print(x // 5 + 1)
x = int(input())
steps(x)


n = int(input())
c = 0
while True:
	if n <= 5:
		c += 1
		break
	else:
		n -= 5
		c += 1
print(c)


x = int(input())
a = 0
if x % 5 != 0:
	a = 1
print(str(x // 5 + a))


n = int(input())
m = n
a = m % 5
m = m - a
c1 = m // 5
if a == 0:
	print(c1)
else:
	print(c1 + 1)


x = int(input())
c = 0
if x % 5 != 0:
	c = x // 5 + 1
else:
	c = x // 5
print(c)


n = int(input())
cn = 0
if n >= 5:
	cn += int(n / 5)
	n = n % 5
if n >= 4:
	cn += int(n / 4)
	n = n % 4
if n >= 3:
	cn += int(n / 3)
	n = n % 3
if n >= 2:
	cn += int(n / 2)
	n = n % 2
if n >= 1:
	cn += int(n / 1)
	n = n % 1
print(cn)


q = int(input())
p = q
p = p // 5
if q % 5 != 0:
	p += 1
print(p)


try:
	total_steps = int(input())
	if total_steps % 5 == 0:
		print(total_steps // 5)
	elif total_steps % 5 < 0:
		print(total_steps // 5 - 1)
	else:
		print(total_steps // 5 + 1)
except EOFError:
	pass


import math
N = input()
N = int(N)
X = 5
q = math.ceil(N / X)
print(q)


def counting_steps(x):
	ans = 0
	while x != 0:
		if x >= 5:
			x -= 5
			ans += 1
		elif x == 4:
			x -= 4
			ans += 1
		elif x == 3:
			x -= 3
			ans += 1
		elif x == 2:
			x -= 2
			ans += 1
		elif x == 1:
			x -= 1
			ans += 1
	return ans
x = int(input())
print(counting_steps(x))


lit = [5, 4, 3, 2, 1]
a = int(input())
count = 0
for i in lit:
	while a // i > 0 and a != 0:
		a = a - i
		count += 1
print(count)


a = int(input())
b = 0
if a <= 5:
	b = 1
elif a > 5 and a % 5 == 0:
	b = int(a / 5)
else:
	b = int(a / 5) + 1
print(b)


tar = int(input())
if tar % 5 == 0:
	print(tar // 5)
else:
	print(tar // 5 + 1)


import math
x = int(input())
print(str(math.ceil(x / 5)))


x = int(input())
step_available = [range(1, 6)]
step_count = 0
distance_left = x
while distance_left > 0:
	if distance_left >= 5:
		distance_left -= 5
		step_count += 1
	elif 0 < distance_left < 5:
		distance_left = 0
		step_count += 1
print(step_count)


num = int(input())
a = [5, 4, 3, 2, 1]
count = 0
i = 0
if num <= 5:
	print(1)
else:
	while num != 0:
		flag = num
		if flag - a[i] >= 0:
			count = count + 1
			num = num - a[i]
		else:
			i = i + 1
	print(count)


V = int(input())
deno = [1, 2, 3, 4, 5]
ans = 0
n = len(deno)
i = n - 1
while i >= 0:
	while V >= deno[i]:
		V -= deno[i]
		ans += 1
	i -= 1
print(ans)


x = int(input())
if x % 5 == 0:
	print(int(x / 5))
else:
	print(int((x + 5 - x % 5) / 5))


a = int(input())
sum = 0
for i in reversed(range(1, 6)):
	if a // i > 0:
		s = a // i
		a = a - s * i
		sum += s
print(sum)


a = int(input())
count = 0
for x in range(0, a):
	if a >= 5:
		a = a - 5
		count = count + 1
	elif a >= 4:
		a = a - 4
		count = count + 1
	elif a >= 3:
		a = a - 3
		count = count + 1
	elif a >= 2:
		a = a - 2
		count = count + 1
	elif a >= 1:
		a = a - 1
		count = count + 1
	else:
		count = count
print(count)


x = int(input())
numOfSteps = 0
l = [5, 4, 3, 2, 1]
for i in l:
	numOfSteps += x // i
	x = x % i
print(numOfSteps)


n = int(input())
s = 0
for i in [5, 4, 3, 2, 1]:
	s += n // i
	n %= i
	if n == 0:
		break
print(s)


x = int(input())
a = x % 5
b = x // 5
if x == 1 or x == 2 or x == 3 or (x == 4) or (x == 5):
	print('1')
elif a == 0:
	print(b)
elif a != 0:
	print(b + 1)


x = int(input())
first_steps = x // 5
remainder = x % 5
if remainder == 0:
	print(first_steps)
else:
	print(first_steps + 1)


t = int(input())
if t % 5:
	print(int(t / 5 + 1))
else:
	print(int(t / 5))


a = int(input())
n1 = 0
n2 = 0
n3 = 0
n4 = 0
n5 = 0
if a <= 5:
	print(1)
elif a > 5:
	n1 = a // 5
	a = a - 5 * n1
	if a > 0:
		n2 = a // 4
		a = a - n2 * 4
		if a > 0:
			n3 = a // 3
			a = a - n3 * 3
			if a > 0:
				n4 = a // 2
				a = a - n4 * 2
				if a > 0:
					n5 = a
	print(n5 + n4 + n3 + n2 + n1)


n = int(input())
fives = n // 5
n = n - fives * 5
fours = n // 4
n = n - fours * 4
threes = n // 3
n = n - threes * 3
twos = n // 2
n = n - twos * 2
ones = n // 1
n = n - ones * 1
print(int(ones + twos + threes + fours + fives))


num = int(input())
total = 1
while num > 5:
	num -= 5
	total += 1
print(total)


x = int(input())
if x % 5 == 1 or x % 5 == 2 or x % 5 == 3 or (x % 5 == 4) or (x % 5 == 5):
	print(x // 5 + 1)
else:
	print(int(x / 5))


steps = [1, 2, 3, 4, 5]
n = int(input())
(aux, count) = (0, 0)
while aux != n:
	for i in range(len(steps) - 1, -1, -1):
		if aux + steps[i] <= n:
			aux += steps[i]
			break
	count += 1
print(count)


def solve():
	x = int(input())
	s5 = x // 5
	x -= s5 * 5
	s4 = x // 4
	x -= s4 * 4
	s3 = x // 3
	x -= s3 * 3
	s2 = x // 2
	x -= s2 * 2
	s1 = x
	print(s1 + s2 + s3 + s4 + s5)
solve()


dis = int(input())
steps = dis // 5
if dis % 5 != 0:
	steps += 1
print(steps)


i = int(input())
j = []
k = []
for a in range(1, 6):
	b = i / a
	j.append(b)
len = len(j)
for c in range(0, len):
	if j[c] >= 1:
		k.append(j[c])
m = min(k)
m1 = m // 1
g = i / m
if i % g == 0:
	print(int(m1))
else:
	print(int(m1 + 1))


d = int(input())
steps = 0
k = 5
while d > 0:
	steps += d // k
	d = d % k
	k -= 1
print(steps)


n = int(input())
steps = 0
steps += n // 5
n = n % 5
steps += n // 4
n = n % 4
steps += n // 3
n = n % 3
steps += n // 2
n = n % 2
steps += n
print(steps)


ls = [5, 4, 3, 2, 1]
x = int(input())
cnt = 0
for i in range(5):
	while x > 0:
		if ls[i] <= x:
			x -= ls[i]
			cnt += 1
		else:
			break
print(cnt)


test = int(input())
if test % 5 == 0:
	print(int(test / 5))
else:
	print(int(test / 5) + 1)


n = int(input())
count_steps = 0
count_steps += n // 5
n %= 5
count_steps += n // 4
n %= 4
count_steps += n // 3
n %= 3
count_steps += n // 2
n %= 2
count_steps += n // 1
n %= 1
print(count_steps)


a = int(input())
if a % 5 == 0:
	print(round(a / 5))
else:
	print(round(a // 5 + 1))


x = int(input())
remainder = x
stepscounter = 0
for i in range(x):
	if remainder >= 5:
		remainder = remainder - 5
		stepscounter = stepscounter + 1
	elif remainder > 0:
		remainder = 0
		stepscounter = stepscounter + 1
print(stepscounter)


def main():
	result = int(input())
	count = 0
	while result > 5:
		result -= 5
		count += 1
	count += 1
	print(count)
main()


n = int(input())
x = 0
if n >= 5:
	x += n // 5
	n = n % 5
if n == 4:
	x += 1
if n == 3:
	x += 1
if n == 2:
	x += 1
if n == 1:
	x += 1
print(x)


x = int(input())
print(x // 5 + x % 5 // 4 + x % 5 % 4 // 3 + x % 5 % 4 % 3 // 2 + x % 5 % 4 % 3 % 2)


import math
n = int(input())
ls = [5, 4, 3, 2, 1]
count = 0
while n > 0:
	for i in ls:
		if n >= i:
			n -= i
			count += 1
			break
print(count)


import math

def main():
	x = int(input())
	(lnt, x) = (x // 5, x % 5)
	(lnt, x) = (lnt + x // 4, x % 4)
	(lnt, x) = (lnt + x // 3, x % 3)
	(lnt, x) = (lnt + x // 2, x % 2)
	lnt = lnt + x // 1
	print(lnt)
main()


n = int(input())
s = 5
x = 0
while n > 0:
	y = int(n / s)
	x += y
	n -= y * s
	s = s - 1
print(x)


x = int(input())
if x % 5 == 0:
	print(x // 5)
else:
	a = x % 5
	if a % 4 == 0:
		print(x // 5 + a // 4)
	else:
		b = a % 4
		if b % 3 == 0:
			print(x // 5 + a // 4 + b // 3)
		else:
			c = b % 3
			if c % 2 == 0:
				print(x // 5 + a // 4 + b // 3 + c // 2)
			else:
				print(x // 5 + a // 4 + b // 3 + c // 2 + c)


n = int(input())
count = n // 5
if n % 5:
	count += 1
print(count)


n = int(input())
total = 0
for x in range(5, 0, -1):
	if n >= x:
		(t, remainder) = divmod(n, x)
		total += t
		n = remainder
print(total)


x = int(input())
steps = 0
if x >= 5:
	steps = steps + int(x / 5)
	x = x % 5
if x >= 4:
	steps = steps + int(x / 4)
	x = x % 4
if x >= 3:
	steps = steps + int(x / 3)
	x = x % 3
if x >= 2:
	steps = steps + int(x / 2)
	x = x % 2
if x >= 1:
	steps = steps + int(x / 1)
	x = x % 1
print(steps)


inn = int(input())
step = 5
count = 0
while inn > 0:
	a = inn - step
	if a >= 0:
		inn = a
		count += 1
	else:
		step -= 1
print(count)


n = int(input())
step = 0
mod = 0
if n > 5:
	mod = n % 5
	if mod != 0:
		step = n // 5 + 1
	else:
		step = n // 5
else:
	step = 1
print(step)


distancia = int(input())
passos = 0
if distancia <= 5:
	print(1)
else:
	if distancia % 5 != 0:
		passos = 1
	passos = passos + distancia // 5
	print(passos)


import math
a = int(input())
print(math.ceil(min(a / 1, a / 2, a / 3, a / 4, a / 5)))


import math
l = [1, 2, 3, 4, 5]
x = int(input())
s = []
p = []
a = []
if x in l:
	print(1)
else:
	p = [x / i for i in l]
	for j in p:
		s = math.ceil(j)
	print(s)


fi = 0
fo = 0
t = 0
tw = 0
o = 0
x = int(input())
for i in range(5, x + 1, 5):
	fi += 1
x = x - fi * 5
for i in range(4, x + 1, 4):
	fo += 1
x = x - fo * 4
for i in range(3, x + 1, 3):
	t += 1
x = x - t * 3
for i in range(2, x + 1, 2):
	tw += 1
x = x - tw * 2
print(fi + fo + t + tw + x)


n = int(input())
i = 5
count = 0
while n > 0:
	if n >= i:
		count = count + int(n / i)
		n = int(n % i)
		i -= 1
	else:
		i -= 1
print(count)


dis = int(input())
if dis % 5 == 0:
	print(dis // 5)
else:
	print(dis // 5 + 1)


n = int(input())
cont = 0
while n - 5 >= 0:
	n -= 5
	cont += 1
while n - 4 >= 0:
	n -= 4
	cont += 1
while n - 3 >= 0:
	n -= 3
	cont += 1
while n - 2 >= 0:
	n -= 2
	cont += 1
while n - 1 >= 0:
	n -= 1
	cont += 1
print(cont)


i = int(input())
ans = i // 5
if i % 5 == 0:
	print(ans)
else:
	print(ans + 1)


n = int(input())
steps = 0
for i in range(5, 0, -1):
	steps = steps + n // i
	n = n % i
print(steps)


b = int(input())
print((b + 4) // 5)


distance_left = int(input())
steps = 5
moves = 0
while distance_left != 0:
	while steps > distance_left:
		steps -= 1
	for _ in range(distance_left // steps):
		distance_left -= steps
		moves += 1
print(moves)


w = int(input())
t = w // 5
if w - t * 5 == 0:
	print(t)
else:
	print(t + 1)


from math import ceil
n = int(input())
answer = ceil(n / 5)
print(answer)


import math
x = int(input())
t = x / 5
print(math.ceil(t))


x = int(input())
steps = [5, 4, 3, 2, 1]
time = 0
for step in steps:
	time += x // step
	x = x % step
print(time)


n = int(input())
count = 1
while n != 1 and n != 2 and (n != 3) and (n != 4) and (n != 5):
	count += 1
	n -= 5
print(count)


x = int(input())
r = x % 5
d = x // 5
s = 0
if r < 6 and r > 0:
	s = 1
elif r < 10 and r > 0:
	s = 2
elif r < 13 and r > 0:
	s = 3
elif r < 15 and r > 0:
	s = 4
elif r < 16 and r > 0:
	s = 5
o = d + s
print(o)


x = int(input())
if x % 5 == 0:
	pasos = x // 5
else:
	pasos = x // 5 + 1
print(pasos)


distance = int(input())
result = 0
for i in range(5):
	current = 5 - i
	times = distance // current
	result += times
	distance %= current
print(result)


import math
x = float(input())
res = x / 5
res = math.ceil(res)
print(res)


i = int(input())
print(str(i // 5 + (i % 5 > 0)))


a = int(input(''))
if a % 5 == 0:
	d = int(a / 5)
	print(str(d))
else:
	b = int(a / 5)
	c = int(b + 1)
	print(str(c))


x = int(input())
if x % 5 == 0:
	res = int(x / 5)
	print(res)
else:
	res = int(x / 5 + (-(x % 5 * 2) / 10 + 1))
	print(res)


n = int(input())
arr = [5, 4, 3, 2, 1]
x = 0
i = 0
while n != 0:
	x += n // arr[i]
	n = n % arr[i]
	i += 1
print(x)


import math
l = int(input())
n = math.ceil(l / 5)
print(n)


number = int(input())
if number <= 5:
	print(1)
elif number % 5 != 0:
	print(number // 5 + 1)
else:
	print(number // 5)


user = int(input())
steps = 0
while user != 0:
	if user - 5 >= 0:
		user -= 5
		steps += 1
		continue
	elif user - 4 >= 0:
		user -= 4
		steps += 1
		continue
	elif user - 3 >= 0:
		user -= 3
		steps += 1
		continue
	elif user - 2 >= 0:
		user -= 2
		steps += 1
		continue
	elif user - 1 >= 0:
		user -= 1
		steps += 1
		continue
print(steps)


n = int(input())
l = [1, 2, 3, 4, 5]
count = 0
result = 0
maximam = 0
while n > 0:
	maximam = max(l)
	if n >= maximam:
		n = n - maximam
		count += 1
	else:
		l.remove(maximam)
print(count)


import sys
import math as mt
t = 1
for __ in range(t):
	n = int(input())
	if n % 5 == 0:
		print(n // 5)
	else:
		print(n // 5 + 1)


x = int(input())
z = (x + 4) // 5
print(z)


a = int(input())
print(a // 5 + 1 - 0 ** (a % 5))


a = int(input())
b = [1, 2, 3, 4, 5]
if a in b:
	print(1)
elif a % 5 == 0:
	q = int(a / 5)
	print(q)
else:
	q = int(a / 5)
	print(q + 1)


s = 0
distance = int(input())
while distance > 5:
	s += 1
	distance -= 5
s += 1
print(s)


khoangCach = int(input())
soLanDi = int(khoangCach / 5)
if khoangCach <= 0:
	soLanDi = 0
elif khoangCach % 5 != 0:
	soLanDi += 1
print(soLanDi)


import sys
n = int(sys.stdin.readline().rstrip())
ss = 0
for i in range(5, 0, -1):
	ss += n // i
	n = n % i
print(ss)


a = int(input())
if a // 5 == 0:
	result = 1
if a // 5 > 0:
	b = a // 5
	if a - 5 * b > 0:
		result = b + 1
	elif a - 5 * b == 0:
		result = b
print(result)


from math import floor
x = int(input())
n = 0
n += floor(x / 5)
if x % 5 != 0:
	n += 1
print(n)


import sys
import math
x = int(sys.stdin.readline())
output = math.ceil(x / 5)
sys.stdout.write(str(output))


k = int(input())
m = 0
while k != 0:
	if k >= 5:
		m = m + 1
		k = k - 5
	else:
		m = m + 1
		k = 0
print(m)


n = int(input())
cnt = 0
while n - 5 >= 0:
	n = n - 5
	cnt += 1
while n - 4 >= 0:
	n = n - 4
	cnt += 1
while n - 3 >= 0:
	n = n - 3
	cnt += 1
while n - 2 >= 0:
	n = n - 2
	cnt += 1
while n - 1 >= 0:
	n = n - 1
	cnt += 1
print(cnt)


final_position = int(input())
if final_position <= 5:
	print(1)
else:
	result = final_position // 5
	if final_position % 5 != 0:
		result += 1
	print(result)


n = int(input())
count = 0
for i in [5, 4, 3, 2, 1]:
	if n >= i:
		q = n // i
		count += q
		n = n % i
		if n == 0:
			print(count)
			quit()


import math
a = int(input())
print(math.ceil(a / 5.0))


x = int(input())
y = x / 5
z = x // 5
if x <= 5:
	print(1)
elif x > 5 and x <= 10:
	print(2)
elif x > 10:
	if y == z:
		print(z)
	else:
		w = z + 1
		print(w)


n = int(input())
cont = 0
if n >= 5:
	cont = cont + int(n / 5)
	n = n % 5
if n >= 4:
	cont = cont + int(n / 4)
	n = n % 4
if n >= 3:
	cont = cont + int(n / 3)
	n = n % 3
if n >= 2:
	cont = cont + int(n / 2)
	n = n % 2
cont = cont + n
print(cont)


n = int(input())
i = 5
cnt = 0
while i > 0 and n > 0:
	cnt += n // i
	n = n - n // i * i
	i -= 1
print(cnt)


import math
x = int(input())
l = [x / 5, x / 4, x / 3, x / 2, x / 1]
l.sort()
print(math.ceil(l[0]))


x = int(input())
y = x // 5
z = x % 5
add = 0
if z != 0:
	add += 1
print(y + add)


n = int(input())
step = [5, 4, 3, 2, 1]
count = 0
step_sum = 0
while step_sum < n:
	for i in range(5):
		if step_sum + step[i] <= n:
			step_sum += step[i]
			count += 1
			break
print(count)


n = int(input())
count = n // 5
n = n % 5
count += n // 4
n = n % 4
count += n // 3
n = n % 3
count += n // 2
n = n % 2
count += n
print(count)


a = int(input())
if a < 5:
	print(1)
elif a % 5 == 0:
	print(a // 5)
else:
	s = a // 5 + 1
	print(s)


n = int(input())
result = 0
k = int(n / 5)
n -= k * 5
result += k
k = int(n / 4)
n -= k * 4
result += k
k = int(n / 3)
n -= k * 3
result += k
k = int(n / 2)
n -= k * 2
result += k
result += n
print(result)


n = int(input())
l = [5, 4, 3, 2, 1]
s = 0
for i in l:
	s += n // i
	n %= i
print(s)


amount = int(input())
amounts = [5, 4, 3, 2, 1]
bills = 0
i = 0
while i < 5 and amount != 0:
	if amount % amounts[i] == 0:
		bills += amount // amounts[i]
		amount = 0
	elif amount % amounts[i] == amount:
		i += 1
	else:
		old_amount = amount
		amount = amount % amounts[i]
		bills += (old_amount - amount) // amounts[i]
print(str(bills))


s = int(input())
c = 0
if s > 5:
	while s > 5:
		s = s - 5
		c = c + 1
print(c + 1)


def Elephi(x, step):
	if x <= 5:
		print(step)
	else:
		step += x // 5
		x = x % 5
		if x == 0:
			step -= 1
		Elephi(x, step)
x = int(input())
step = 1
Elephi(x, step)


x = input('')
y = int(x)
step5 = int(y / 5)
remaining = y - step5 * 5
if remaining != 0:
	print(step5 + 1)
else:
	print(step5)


def main():
	num = int(input())
	check = 0
	while True:
		check += 1
		if 5 * check >= num:
			print(check)
			break
		else:
			pass
main()


x = int(input().strip())
steps = 0
while x > 5:
	x -= 5
	steps += 1
steps += 1
print(steps)


def main():
	x = int(input())
	c = 0
	for n in range(5, 0, -1):
		c += x // n
		x %= n
	print(c)
main()


x = int(input())
d = x / 5
r = x % 5
if 1 <= x <= 5:
	print('1')
elif r == 0:
	print(int(d))
elif 1 <= r <= 5:
	d += 1
	print(int(d))


x = int(input())
cos = 0
cos += x // 5
r = x % 5
cos += r // 4
r = r % 4
cos += r // 3
r = r % 3
cos += r // 2
r = r % 2
cos += r
print(cos)


n = int(input())
result = 0
for iterate in range(5, 0, -1):
	result += n // iterate
	n = n % iterate
print(result)


import math
n = int(input())
count = 0
if n == 5 or n == 4 or n == 3 or (n == 2) or (n == 1):
	print(1)
else:
	print(math.ceil(n / 5))


x = int(input())
counter = 0
while x != 0:
	while True:
		if x >= 5:
			x -= 5
			counter += 1
			break
		elif x >= 4:
			x -= 4
			counter += 1
			break
		elif x >= 3:
			x -= 3
			counter += 1
			break
		elif x >= 2:
			x -= 2
			counter += 1
			break
		elif x >= 1:
			x -= 1
			counter += 1
			break
print(counter)


x = int(input())
possible_moves = [5, 4, 3, 2, 1]
count = 0
for move in possible_moves:
	if x < move:
		continue
	count += x // move
	x = x % move
	if x == 0:
		break
print(count)


a = int(input())
count = 0
while a != 0:
	if a >= 5:
		count += 1
		a = a - 5
	elif a == 4:
		count += 1
		a = a - 4
	elif a == 3:
		count += 1
		a = a - 3
	elif a == 2:
		count += 1
		a = a - 2
	else:
		count += 1
		a = a - 1
print(count)


put = int(input())
if put / 5 == int(put / 5):
	print(int(put / 5))
else:
	print(int(put / 5) + 1)


import math

def minSteps(x: int) -> int:
	withOne = math.ceil(x / 1)
	withTwo = math.ceil(x / 2)
	withThree = math.ceil(x / 3)
	withFour = math.ceil(x / 4)
	withFive = math.ceil(x / 5)
	return min(withOne, withTwo, withThree, withFour, withFive)

def main():
	x = int(input().strip())
	print(minSteps(x))
main()


n = int(input())
a = int((n + 5 - 1) / 5)
print(a)


count = 0
x = int(input())
a = x // 5
b = x - a * 5
if b == 0:
	count = count + a
else:
	count = count + a + 1
print(count)


n = int(input())
R = n % 5
if R == 0:
	Z = n // 5
else:
	Z = n // 5 + 1
print(Z)


a = int(input())
c = a // 5
d = a % 5
print([c + 1, c][d == 0])


import sys
friend_x = int(sys.stdin.readline())
distance = friend_x / 5
final_result = distance
if friend_x % 5 != 0:
	final_result = final_result + 1
print(int(final_result))


a = int(input())
if a in range(1, 6):
	print(1)
elif a % 5 == 0:
	print(a // 5)
else:
	print(a // 5 + 1)


vlt = [5, 4, 3, 2, 1]
n = int(input())
c = 0
for v in vlt:
	if n % v != n:
		c += n // v
		n = n % v
print(c)


length = int(input())
step = length // 5
rest = length % 5
if rest:
	step += 1
print(step)


dist = int(input())
rest = 1 if dist % 5 != 0 else 0
print(dist // 5 + rest)


n = int(input())
a5 = int(n / 5)
n = n % 5
a4 = int(n / 4)
n = n % 4
a3 = int(n / 3)
n = n % 3
a2 = int(n / 2)
n = n % 2
a1 = n
print(a1 + a2 + a3 + a4 + a5)


n = int(input())
lst = [5, 4, 3, 2, 1]
curr = 0
count = 0
while n > 0 and curr < 5:
	if n >= lst[curr]:
		n -= lst[curr]
		count += 1
	else:
		curr += 1
print(count)


n = int(input())
move = 0
if n / 5 > 0:
	move = move + n // 5
	n = n % 5
if n / 4 > 0:
	move = move + n // 4
	n = n % 4
if n / 3 > 0:
	move = move + n // 3
	n = n % 3
if n / 2 > 0:
	move = move + n // 2
	n = n % 2
if n / 1 > 0:
	move = move + n // 1
	n = n % 1
print(move)


def check(n):
	mov = 5
	cnt = 0
	while n != 0:
		if mov <= n:
			n = n - mov
			cnt += 1
		else:
			mov -= 1
	return cnt

def main():
	n = input()
	ans = check(int(n))
	print(ans)
main()


b = int(input())
steps = [5, 4, 3, 2, 1]

def elephant(b, steps):
	i = 0
	moves = 0
	steps_left = b
	while steps_left != 0:
		if steps_left >= steps[i]:
			moves += steps_left // steps[i]
			steps_left = steps_left % steps[i]
		else:
			i += 1
	print(moves)
elephant(b, steps)


n = int(input())
x = 0
while n != 0:
	if n >= 5:
		x += 1
		n -= 5
	else:
		x += 1
		n = 0
print(x)


x = int(input())
t = 5
q = 0
m = x / t + (x % 5 > q)
print(int(m))


tar = int(input())
ret = tar // 5
if tar % 5 > 0:
	ret += 1
print(ret)


x = int(input())
if x % 5 != 0:
	print(str(int(x / 5) + 1))
else:
	print(str(int(x / 5)))


position = int(input())
if position % 5 == 0:
	step = position // 5
else:
	step = position // 5 + 1
print(step)


n = int(input())
elephantMoves = [1, 2, 3, 4, 5]
i = 4
num = 0
while n != 0:
	if n - elephantMoves[i] >= 0:
		n = n - elephantMoves[i]
		num = num + 1
	else:
		i = i - 1
print(num)


x = int(input())
steps = 0
steps += x // 5
x = x % 5
if x >= 4:
	steps += x // 4
	x = x % 4
if x >= 3:
	steps += x // 3
	x = x % 3
if x >= 2:
	steps += x // 2
	x = x % 2
else:
	steps += x
print(steps)


length = int(input())
move = length // 5
if length % 5 != 0:
	move += 1
print(move)


masukan = int(input())
output = 0
if masukan > 4:
	output = int(masukan / 5)
if masukan % 5 != 0:
	output = output + 1
print(output)


x = int(input())
ret = x // 5
if x % 5 != 0:
	ret += 1
print(ret)


N = int(input())
ans = N // 5
if N % 5 != 0:
	ans += 1
print(ans)


dis = int(input())
steps = dis // 5
if dis % 5 != 0:
	steps += 1
	print(steps)
elif dis % 5 == 0:
	print(steps)
else:
	steps = 1
	print(steps)


def tusk(n):
	s5 = n // 5
	r = 1 if n % 5 != 0 else 0
	return s5 + r
n = int(input())
print(tusk(n))


n = int(input())
k = n % 5
if k < 6 and k != 0:
	print(n // 5 + 1)
else:
	print(n // 5)


import math
steps = 0
n = int(input())
if n % 5 != n:
	steps += math.floor(n / 5)
	n = n % 5
if n % 4 != n:
	steps += math.floor(n / 4)
	n = n % 4
if n % 3 != n:
	steps += math.floor(n / 3)
	n = n % 3
if n % 2 != n:
	steps += math.floor(n / 2)
	n = n % 2
if n > 0:
	steps += 1
print(steps)


import math
n = int(input())
steps = math.floor(n / 5)
if steps == n / 5:
	print(steps)
else:
	steps += 1
	print(steps)


a = int(input())
a100 = a // 5
a20 = a % 5 // 4
a10 = a % 5 % 4 // 3
a5 = a % 5 % 4 % 3 // 2
a1 = a % 5 % 4 % 3 % 2 // 1
a = a100 + a20 + a10 + a5 + a1
print(a)


import sys
friend_distance = int(input())
number_of_steps = friend_distance // 5
if friend_distance % 5 > 0:
	number_of_steps += 1
print(number_of_steps)


def solve():
	y = int(input())
	print(int((y + 4) / 5))
solve()


x = int(input())
steps = [5, 4, 3, 2, 1]
counter = 0
i = 0
while x > 0:
	if x - steps[i] >= 0:
		x -= steps[i]
		counter += 1
	else:
		i += 1
print(counter)


masukan = int(input())
step = 0
for item in [5, 4, 3, 2, 1]:
	if masukan / item >= 1:
		now = int(masukan / item)
		step = step + now
		masukan = masukan - now * item
print(step)


dist = int(input())
step = dist // 5
dist -= step * 5
if dist != 0:
	step += 1
print(step)


n = int(input())
count = 0
steps = 0
if n < 6:
	print('1')
else:
	while steps < n:
		if steps + 5 <= n:
			count += 1
			steps += 5
		elif steps + 4 <= n:
			count += 1
			steps += 4
		elif steps + 3 <= n:
			count += 1
			steps += 3
		elif steps + 2 <= n:
			count += 1
			steps += 2
		elif steps + 1 <= n:
			count += 1
			steps += 1
	print(count)


import math
number = int(input())
step5 = math.floor(number / 5)
if number / 5 > step5:
	print(step5 + 1)
else:
	print(step5)


x = int(input().strip())
c = 0
while x != 0:
	if x > 5:
		x = x - 5
		c = c + 1
	else:
		x = 0
		c = c + 1
print(c)


import math
n = int(input())
a = math.ceil(n / 5)
print(a)


distance = int(input())
quot = 0
list = [1, 2, 3, 4]
if distance >= 5:
	reminder = distance % 5
	quot = int(distance / 5)
	if reminder != 0:
		quot = quot + 1
else:
	quot = 1
print(quot)


n = int(input())
if n % 5 == 0:
	antal = int(n / 5)
else:
	antal = int(n / 5) + 1
print(antal)


import math
x = int(input())
result = x / 5.0
result = math.ceil(result)
if result > 0:
	print(result)
else:
	print('1')


steps = (5, 4, 3, 2, 1)
n = int(input())
nbStep = 0
while n != 0:
	for e in steps:
		nbStep += int(n / e)
		n %= e
print(nbStep)


k = int(input())
p = 0
if k % 5 != 0:
	p = 1
print(k // 5 + p)


n = int(input())
c = 0
l = [1, 2, 3, 4, 5]
quo = n // 5
rem = n % 5
if rem in l:
	c = 1
print(quo + c)


x = int(input())
steps = 0
moves = [5, 4, 3, 2, 1]
ind = 0
while ind < len(moves):
	if x >= moves[ind]:
		steps += x // moves[ind]
		x = x % moves[ind]
	ind += 1
print(steps)


n = int(input())
L = [1, 2, 3, 4, 5]
C = 0
while n != 0:
	C += n // max(L)
	n = n - n // max(L) * max(L)
	L.remove(max(L))
print(C)


f = int(input())
if f % 5 == 0:
	print((f - f % 5) // 5)
else:
	print((f - f % 5) // 5 + 1)


n = int(input())
s5 = int(n / 5)
n = n - s5 * 5
s4 = int(n / 4)
n = n - s4 * 4
s3 = int(n / 3)
n = n - s3 * 3
s2 = int(n / 2)
n = n - s2 * 2
print(n + s2 + s3 + s4 + s5)


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

def multiple_input():
	return map(int, input().split())
n = int(input())
x = 0
while n > 5:
	x += 1
	n -= 5
if n > 0:
	x += 1
print(x)


no = int(input())
print((no + 4) // 5)


w = int(input())
r = w // 5
if w % 5 == 0:
	print(r)
else:
	print(r + 1)


x = input()
x = int(x)
adder = 0
while x > 0:
	if x > 5:
		x -= 5
		adder += 1
	else:
		adder += 1
		x = 0
print(adder)


pos = int(input())
cnt = 0
while pos > 0:
	if pos >= 5:
		pos -= 5
	else:
		pos -= pos
	cnt += 1
print(cnt)


x = int(input())
y = x
n = 0
for i in (5, 4, 3, 2, 1):
	n += x // i
	x %= i
	if x % i == 0:
		break
print(n)


a = int(input())
i = 5
ctr = 0
while i > 0:
	if a % i == 0:
		ctr += int(a / i)
		print(ctr)
		break
	else:
		ctr += int(a / i)
		a = a % i
	i -= 1


Z = int(input())
Ans = Z // 5
if Z % 5 == 0:
	print(Ans)
else:
	print(Ans + 1)


c = int(input())
p = 0
if c <= 5:
	print('1')
else:
	a = c // 5
	if c % 5 == 0:
		print(a)
	else:
		print(a + 1)


def solve(x):
	return x // 5 + (x % 5 != 0)
x = int(input())
print(solve(x))


l = [1, 2, 3, 4, 5]
n = int(input())
c = 0
if n in l:
	c += 1
elif n > 5:
	c += n // 5
	n = n % 5
	if n in l:
		c += 1
print(c)


w = int(input())
result = 0
while w // 5 != 0:
	w -= 5
	result += 1
if w > 0:
	result += 1
print(result)


n = int(input(''))
l = 0
if n // 5 >= 1:
	l = l + n // 5
	n = n % 5
if n // 4 >= 1:
	l = l + n // 4
	n = n % 4
if n // 3 >= 1:
	l = l + n // 3
	n = n % 3
if n // 2 >= 1:
	l = l + n // 2
	n = n % 2
if n // 1 >= 1:
	l = l + n // 1
	n = n % 1
print(l)


n = int(input())
if n % 5 == 0:
	print(int(n / 5))
elif n % 5 != 0:
	while n % 5 != 0:
		n -= 1
		if n % 5 == 0:
			print(int(n / 5 + 1))


x = int(input())
n = 0
v = 0
while x > n:
	n += 5
	v += 1
print(v)


x = int(input())
n = 5
ans = 0
while n >= 1:
	ans += int(x / n)
	x = int(x % n)
	n -= 1
print(ans)


i = int(input())
pos = 0
steps = 0
while pos != i:
	if i - pos >= 5:
		pos += 5
	else:
		pos += i - pos
	steps += 1
print(steps)


a = int(input())
e = 0
e += a // 5
a -= a // 5 * 5
e += a // 4
a -= a // 4 * 4
e += a // 3
a -= a // 3 * 3
e += a // 2
a -= a // 2 * 2
e += a // 1
a -= a // 1 * 1
print(e)


t = int(input())
print((t + 4) // 5)


x = int(input())
t = 0
r = x
for i in range(5, 0, -1):
	t += r // i
	r = r % i
print(t)


coordinate = int(input())
elephant_position = 0
no_of_steps = 0
while coordinate != elephant_position:
	if coordinate - elephant_position < 5:
		elephant_position += coordinate - elephant_position
		no_of_steps += 1
	else:
		elephant_position += 5
		no_of_steps += 1
print(no_of_steps)


num = input()
print(int((int(num) + 4) / 5))


x = int(input())
ans = (x - 1) // 5 + 1
print(ans)


a = int(input())
d = a // 5
if a % 5:
	d += 1
print(d)


X = int(input())
R = X / 5
if X % 5 != 0:
	R += 1
print(int(R))


n = int(input())
ans = n // 5
if n % 5:
	ans += 1
print(ans)


a = int(input())
b = 0
for i in range(5, 0, -1):
	b += a // i
	a -= a // i * i
print(b)


x = int(input())
a = x % 5
if a > 0:
	d = x // 5 + 1
else:
	d = x // 5
print(d)


a = int(input())
ar = [5, 4, 3, 2, 1]
i = 0
x = 0
y = 0
while x < 5 and a != 0:
	while ar[x] * i < a:
		i = i + 1
	a = a - ar[x] * i
	x = x + 1
	y = y + i
	i = 0
print(y)


x = int(input())
d = {1: 1, 2: 1, 3: 1, 4: 1, 5: 1}
if x in d:
	print(d[x])
else:
	n = x // 5
	if x % 5:
		print(n + 1)
	else:
		print(n)


x = int(input())
steps = 0
for i in reversed(range(1, 6)):
	steps += int(x / i)
	x %= i
	if x == 0:
		break
print(steps)


l = [5, 4, 3, 2, 1]
n = int(input())
(ans, i) = (0, 0)
while n != 0:
	d = n % l[i]
	if d < n:
		ans += n // l[i]
		n = d
	i += 1
print(ans)


x = int(input())
a = 0
c = 0
for i in range(5):
	if x % (i + 1) == 0:
		a = x // (i + 1)
for i in range(5):
	for j in range(5):
		if (x + j + 1) % (i + 1) == 0 and (x + j + 1) // (i + 1) < a:
			c = (x + j + 1) // (i + 1)
if c == 0:
	print(a)
else:
	print(c)


try:
	n = int(input())
	count = 0
	while n > 0:
		n = n - 5
		count += 1
	print(count)
except:
	pass


def main():
	x = int(input())
	koraci = 0
	while x > 0:
		if x >= 5:
			koraci += x // 5
			x = x % 5
		elif x >= 4:
			koraci += x // 4
			x = x % 4
		elif x >= 3:
			koraci += x // 3
			x = x % 3
		elif x >= 2:
			koraci += x // 2
			x = x % 2
		else:
			koraci += x
			x = 0
	print(koraci)
main()


def step(n):
	if n == 0:
		return 0
	elif n % 5 == 0:
		return n // 5
	else:
		return n // 5 + 1
n = int(input())
g = step(n)
print(g)


import math

def solve():
	x = int(input())
	print(math.ceil(x / 5))
solve()


x = int(input())
move = [1, 2, 3, 4, 5]
floormin = []
floor = []
for i in move:
	floormin.append([i, x // i])
	floor.append(x // i)
minfloor = min(floor)
for i in floormin:
	if minfloor == i[1]:
		res = i[0]
if x % res != 0:
	print(minfloor + 1)
else:
	print(minfloor)


num = int(input())
steps = num // 5 + num % 5 // 4 + num % 5 % 4 // 3 + num % 5 % 4 % 3 // 2 + num % 5 % 4 % 3 % 2
print(steps)


Distance = int(input())
Result = Distance // 5
if Distance % 5 > 0:
	Result += 1
print(str(Result))


z = int(input())
c = 0
while z > 0:
	if z > 5:
		c += 1
		z = z - 5
	elif z <= 5:
		c = c + 1
		break
print(c)


x = int(input())
a5 = x // 5
x5 = x - a5 * 5
a4 = x5 // 4
x4 = x5 - a4 * 4
a3 = x4 // 3
x3 = x4 - a3 * 3
a2 = x3 // 2
x2 = x3 - a2 * 2
a1 = x2 // 1
print(a1 + a2 + a3 + a4 + a5)


spaces = int(input())
steps = 0
while spaces > 0:
	if spaces >= 5:
		spaces -= 5
		steps += 1
	elif spaces >= 4:
		spaces -= 4
		steps += 1
	elif spaces >= 3:
		spaces -= 3
		steps += 1
	elif spaces >= 2:
		spaces -= 2
		steps += 1
	elif spaces >= 1:
		spaces -= 1
		steps += 1
print(str(steps))


tot = int(input())
s = {}
for i in range(5, 0, -1):
	s[i] = tot // i
	tot -= s[i] * i
print(s[5] + s[4] + s[3] + s[2] + s[1])


import math
n = input()
n = int(n)
ans = math.floor(n / 5)
if n - 5 * math.floor(n / 5) > 0:
	ans = ans + 1
print(ans)


a = input()
remain = int(a)
steps = 0
while True:
	if int(a) <= 0:
		print(0)
		break
	else:
		if remain >= 5:
			steps += 1
			remain -= 5
		if remain == 4:
			steps += 1
			remain -= 4
		if remain == 3:
			steps += 1
			remain -= 3
		if remain == 2:
			steps += 1
			remain -= 2
		if remain == 1:
			steps += 1
			remain -= 1
		if remain == 0:
			print(steps)
			break


def c(n):
	if n == 0:
		return 0
	else:
		cc = 0
		while n > 0:
			n = min(max(n - 1, 0), max(n - 2, 0), max(n - 3, 0), max(n - 4, 0), max(n - 5, 0))
			cc += 1
		return cc
n = int(input())
print(c(n))


n = int(input())
steps = [5, 4, 3, 2, 1]
steps_count = 0
for i in range(len(steps)):
	if n >= steps[i]:
		steps_count = steps_count + n // steps[i]
		n = n % steps[i]
print(steps_count)


x = int(input())
y = (x + 4) // 5
print(y)


x = int(input())
pas = int(x / 5)
if x % 5 is 0:
	print(pas)
else:
	print(pas + 1)


n = int(input())
s = 0
while n >= 5:
	n = n - 5
	s = s + 1
if n != 0:
	s = s + 1
print(s)


n = int(input())
m = 5
counter = 0
while n != 0:
	if n >= m:
		n -= m
		counter += 1
	else:
		m -= 1
print(counter)


from math import ceil
n = int(input())
b = ceil(n / 5)
print(b)


x = int(input())
mod = x % 5
steps = 0
steps += (x - mod) / 5
if mod > 0:
	steps += 1
print(int(steps))


x = int(input())
steps = 0
for i in [5, 4, 3, 2, 1]:
	if x >= i:
		steps += int(x / i)
		x %= i
print(steps)


n = int(input())
c = 0
while n != 0:
	for x in reversed(range(1, 6)):
		if n >= x:
			n = n - x
			c = c + 1
			break
print(c)


from math import floor
entry = int(input())
res = []
steps = [5, 4, 3, 2, 1]
for i in steps:
	if entry % i >= 0:
		res.append(floor(entry / i))
		entry = entry - floor(entry / i) * i
	else:
		continue
print(int(sum(res)))


x = int(input())
result = 0
x1 = x // 5
result += x1
x2 = x % 5
if x2 >= 4:
	result += 1
	x2 -= 4
if x2 >= 3:
	result += 1
	x2 -= 3
if x2 >= 2:
	result += 1
	x2 -= 2
if x2 >= 1:
	result += 1
	x2 -= 1
print(result)


l = [5, 4, 3, 2, 1]
x = int(input())
s = 0
while x != 0:
	for i in l:
		if x >= i:
			s += x // i
			x %= i
print(s)


x = int(input())
reminder = x
counter = 0
for i in range(x):
	if reminder >= 5:
		reminder = reminder - 5
		counter = counter + 1
	elif reminder > 0:
		reminder = 0
		counter = counter + 1
print(counter)


x = int(input())
count = 0
for i in [5, 4, 3, 2]:
	count += x // i
	x = x % i
count += x
print(count)


x = int(input())
d = (5, 4, 3, 2, 1)
res = 0
for dis in d:
	while x >= dis:
		x -= dis
		res += 1
print(res)


n = int(input())
l = [5, 4, 3, 2, 1]
i = 0
fc = 0
while n != 0:
	while n >= l[i]:
		fc += n // l[i]
		n %= l[i]
	i += 1
print(fc)


x = int(input())
result = 0
while x > 0:
	x -= 5
	result += 1
print(result)


a = int(input())
k = 0
if a % 5 != 0 or a % 5 == 0:
	k += a // 5
	af = a % 5
	if a % 5 != 0:
		k += 1
elif a % 4 != 0 or a % 4 == 0:
	k += a // 4
	af = a % 4
	if a % 4 != 0:
		k += 1
elif a % 3 != 0 or a % 3 == 0:
	k += a // 3
	af = a % 3
	if a % 3 != 0:
		k += 1
elif a % 3 != 0 or a % 3 == 0:
	k += a // 3
	af = a % 3
	if a % 3 != 0:
		k += 1
elif a % 3 != 0 or a % 3 == 0:
	k += a // 3
	af = a % 3
	if a % 3 != 0:
		k += 1
else:
	k += a
print(k)


t = int(input())
s = t // 5
if t % 5 != 0:
	s += 1
print(s)


from collections import defaultdict, deque, Counter, OrderedDict
import threading, sys

def main():
	x = int(input())
	ans = x // 5
	ans += x % 5 > 0
	print(ans)
main()


a = int(input())
cont = a // 5
a = a % 5
cont = cont + a // 4
a = a % 4
cont = cont + a // 3
a = a % 3
cont = cont + a // 2
a = a % 2
cont = cont + a
print(cont)


distance = int(input())
if distance % 5 == 0:
	result = int(distance / 5)
else:
	result = int(distance / 5) + 1
print(result)


x = int(input())
steps = 0
for move in (5, 4, 3, 2, 1):
	n = x // move
	steps += n
	x -= n * move
	if not x:
		break
print(steps)


n = int(input())
cur = 0
ans = 0
while n - cur > 5:
	cur += 5
	ans += 1
print(ans + 1)


n = int(input())
step = 0
temp = 0
while temp + 5 <= n:
	step += 1
	temp += 5
while temp + 4 <= n:
	step += 1
	temp += 4
while temp + 3 <= n:
	step += 1
	temp += 3
while temp + 2 <= n:
	step += 1
	temp += 2
while temp + 1 <= n:
	step += 1
	temp += 1
print(step)


x = int(input())
if x < 5:
	ans = 1
elif x % 5 == 0:
	ans = x / 5
else:
	y = x % 5
	ans = (x - y) / 5 + 1
print(int(ans))


moves = [5, 4, 3, 2, 1]
steps = 0
coordinate = int(input())
for i in moves:
	steps += coordinate // i
	coordinate = coordinate - coordinate // i * i
print(steps)


pos = int(input())
count = 0
while pos > 0:
	pos -= 5
	count += 1
print(count)


import math
t = int(input())
cnt = math.ceil(t / 5)
print(cnt)


from math import *
n = int(input())
k = 0
while n > 0:
	if n >= 5:
		n -= 5
		k += 1
		continue
	elif n >= 4:
		n -= 4
		k += 1
		continue
	elif n >= 3:
		n -= 3
		k += 1
		continue
	elif n >= 2:
		n -= 2
		k += 1
		continue
	elif n >= 1:
		n -= 1
		k += 1
		continue
print(k)


x = int(input())
ans = x // 5
x = x % 5
ans += x // 4
x = x % 4
ans += x // 3
x = x % 3
ans += x // 2
x = x % 2
ans += x // 1
print(ans)


x1 = input()
x = int(x1)
p = x
count = 0
for a in [5, 4, 3, 2, 1]:
	q = int(p / a)
	q1 = p % a
	p = q1
	count = count + q
print(count)


x = int(input())
count = 0
current = 0
for i in reversed(range(5)):
	current = x // (i + 1)
	count += current
	x = x - current * (i + 1)
print(count)


x = int(input())
a = 0
a += x // 5
x = x % 5
a += x // 4
x = x % 4
a += x // 3
x = x % 3
a += x // 2
x = x % 2
a += x // 1
x = x % 1
print(a)


x = int(input())
s = 0
a = 0
while True:
	s += 5
	if s < x:
		a += 1
	else:
		a += 1
		break
print(a)


x = int(input())
t = 0
p = True
while p:
	if x >= 5:
		t = t + 1
		x = x - 5
		if x == 0:
			p = False
	if x < 5 and x != 0:
		t = t + 1
		p = False
print(t)


x = int(input())
n = 0
count = 0
if x == 1:
	print(1)
elif x == 2:
	print(1)
elif x == 3:
	print(1)
elif x == 4:
	print(1)
elif x == 5:
	print(1)
elif x % 5 == 0:
	i = 0
	while x != 0:
		x -= 5
		i += 1
	print(i)
else:
	if x > 5:
		remainder = x - n
		while remainder > 0 and n != x:
			if remainder > 5:
				n += 5
				remainder = x - n
				count += 1
			elif remainder >= 4:
				n += 4
				remainder = x - n
				count += 1
			elif remainder >= 3:
				n += 3
				remainder = x - n
				count += 1
			elif remainder >= 2:
				n += 2
				remainder = x - n
				count += 1
			elif remainder >= 1:
				n += 1
				remainder = x - n
				count += 1
	print(count)


steps = 0
friend = int(input())
for i in range(5, 0, -1):
	steps += friend // i
	friend %= i
print(steps)


n = int(input())
c = 0
a = n
c += a // 5
a = a % 5
c += a // 4
a = a % 4
c += a // 3
a = a % 3
c += a // 2
a = a % 2
c += a // 1
a = a % 1
print(c)


from math import log, ceil, floor

def find_min_num_steps(x_location):
	total_steps = x_location // 5 + ceil(x_location % 5 / 5)
	print(total_steps)
input_str = int(input())
find_min_num_steps(input_str)


n = int(input())
k = 0
li = [5, 4, 3, 2, 1]
for i in li:
	d = n // i
	k = k + d
	n = n % i
print(k)


print(-(-int(input().strip()) // 5))


move = [5, 4, 3, 2, 1]
remainder_step = int(input())
count = 0
for ele in move:
	if ele <= remainder_step:
		count += remainder_step // ele
		remainder_step = remainder_step % ele
print(count)


dist = int(input())
count = 0
for i in range(5, 0, -1):
	count += dist // i
	dist %= i
print(count)


x = int(input())
count = 0
if x <= 5:
	print(1)
else:
	count = x / 5
	x = x % 5
	if x <= 5 and x != 0:
		count += 1
	print(int(count))


import math
n = int(input())
l = 5
sum = 0
if 0 < n <= 5:
	print('1')
else:
	n = n / l
	l -= 1
	sum = sum + n
	print(math.ceil(sum))


import math
x = int(input())
c = x / 5
print(math.ceil(c))


friendHouseX = int(input())
minimumAmountOfSteps = 0
for stepDistance in reversed(range(1, 6)):
	minimumAmountOfSteps += int(friendHouseX / stepDistance)
	friendHouseX %= stepDistance
print(minimumAmountOfSteps)


n = int(input())
steps = 0
for x in range(0, 5):
	step = int(n / (5 - x))
	n -= (5 - x) * step
	steps += step
print(int(steps))


from sys import stdin
input = stdin.readline
n = int(input())
print(n // 5 + 1) if n % 5 else print(n // 5)


n = int(input())
cal = int(n / 5)
rem = n % 5
if rem != 0:
	cal = cal + 1
print(cal)


n = int(input())
ans = n // 5
n %= 5
ans += n // 4
n %= 4
ans += n // 3
n %= 3
ans += n // 2
n %= 2
ans += n
print(ans)


num = int(input())
s = 0
temp = num
for j in range(5, 0, -1):
	s += temp // j
	temp = temp % j
print(s)


x = int(input())
ans = 0
for i in range(1, 6):
	ans += x // (6 - i)
	x -= x // (6 - i) * (6 - i)
print(ans)


h = int(input())
steps_1 = h // 5
steps_1_remain = h % 5
if steps_1_remain == 0:
	print(steps_1)
else:
	print(steps_1 + 1)


x = int(input())
count = 0
if x <= 5:
	print('1')
elif x % 5 == 0:
	while x != 0:
		x = x - 5
		count = count + 1
	print(count)
else:
	while x > 5:
		x = x - 5
		count = count + 1
	print(count + 1)


c = int(input())
ans = 0
for i in range(5, 0, -1):
	ans += c // i
	c %= i
print(ans)


x = int(input())
p = 0
for i in range(x):
	if x == 0:
		break
	elif x == 1:
		p += 1
		x = x - 1
	elif x == 2:
		p += 1
		x = x - 2
	elif x == 3:
		p += 1
		x = x - 3
	elif x == 4:
		p += 1
		x = x - 4
	elif x == 5:
		p += 1
		x = x - 5
	elif x > 5:
		p += 1
		x = x - 5
print(p)


n = int(input())
c = 5
x = 0
total = 0
while n != 0:
	x = n / c
	if int(x) == 0:
		c -= 1
	elif x > 0:
		total = total + int(x)
		n = n - int(x) * c
print(int(total))


x = int(input())
steps = 0
length = 5
while x > 0:
	if x // length > 0:
		steps += x // length
		x = x % length
	length -= 1
print(steps)


x = int(input())
i = 5
n = x // i
otv = x // i
y = n * i
i = 4
while True:
	if y == x:
		print(otv)
		break
	elif y < x and i != 0:
		n = (x - y) // i
		y = y + n * i
		otv += n
		i -= 1
	elif y > x:
		y -= 1
	elif i == 0:
		i = 5


x = int(input())
if x % 5 == 0:
	i = x // 5
else:
	i = x // 5 + 1
print(i)


n = int(input())
s = 0
c = 0
while s < n:
	for i in range(5, 0, -1):
		if s + i > n:
			continue
		else:
			s = s + i
			c += 1
			break
print(c)


input_list = []
num = 0
while True:
	if num == 1:
		break
	line = int(input())
	num += 1
count = 0
counter = 5
while line:
	while counter <= line:
		line -= counter
		count += 1
	counter -= 1
print(count)


try:
	n = int(input())
	ans = 0
	for i in range(5, 0, -1):
		ans += n // i
		n = n % i
	print(ans)
except:
	pass


x = int(input())
steps_count = 0
step_size = 5
while x > 0 and step_size > 0:
	if x - step_size >= 0:
		x -= step_size
		steps_count += 1
	else:
		step_size -= 1
print(str(steps_count))


x = int(input())
z = 0
while 1:
	x = x - 5
	z = z + 1
	if x > 0:
		continue
	else:
		break
print(z)


N = int(input())
A = [5, 4, 3, 2, 1]
C = 0
i = 0
while N >= 0 and i < 5:
	C += N // A[i]
	N = N % A[i]
	i += 1
print(C)


entrada = int(input())
if entrada % 5 != 0:
	res = int(entrada // 5 + 1)
else:
	res = int(entrada // 5)
print(res)


f = int(input())
num = int(f / 5)
reminder = f % 5
if reminder == 0:
	print(num)
else:
	print(num + 1)


length = int(input())
steps = length // 5 + length % 5 // 4 + length % 5 % 4 // 3 + length % 5 % 4 % 3 // 2 + length % 5 % 4 % 3 % 2
print(steps)


def func():
	pos = int(input())
	if pos == 1:
		print(1)
	else:
		steps = [2, 3, 4, 5]
		(i, count) = (0, 0)
		while pos > 0:
			if pos > 5:
				pos -= 5
				count += 1
			elif pos > steps[i]:
				i += 1
			elif pos == steps[i]:
				count += 1
				break
			else:
				pos -= steps[i - 1]
				count += 1
				i = 0
		print(count)
func()


coor = int(input())
if coor % 5 == 0:
	print(coor // 5)
else:
	print(coor // 5 + 1)


x = int(input())
steps = [1, 2, 3, 4, 5]
count = 0
while x != 0:
	if x >= max(steps):
		x = x - 5
		count += 1
	elif x >= max(steps) - 1:
		x = x - 4
		count += 1
	elif x >= max(steps) - 2:
		x = x - 3
		count += 1
	elif x >= max(steps) - 3:
		x = x - 2
		count += 1
	elif x >= max(steps) - 4:
		x = x - 1
		count += 1
	elif x == 0:
		break
print(count)


step = [1, 2, 3, 4, 5]
x = int(input())
nb = 0
pos = 0
while pos != x:
	if x - pos >= 5:
		pos += step[4]
	elif x - pos in step:
		pos += x - pos
	nb += 1
print(nb)


a = int(input())
l = [5, 4, 3, 2, 1]
(f, i) = (0, 0)
while a > 0:
	f += a // l[i]
	a = a % l[i]
	i = i + 1
print(f)


pos = int(input())
res = 0
while pos > 0:
	res += pos // 5
	pos = pos % 5
	res += pos // 4
	pos = pos % 4
	res += pos // 3
	pos = pos % 3
	res += pos // 2
	pos = pos % 2
	res += pos
	pos = pos % 5
	pos -= 1
print(res)


len = int(input())
if len % 5 == 0:
	print(len // 5)
else:
	print(len // 5 + 1)


s = int(input())
c = 0
if s >= 5:
	c += s // 5
	s = s % 5
if s >= 4:
	c += s // 4
	s = s % 4
if s >= 3:
	c += s // 3
	s = s % 3
if s >= 2:
	c += s // 2
	s = s % 2
if s >= 1:
	c += s // 1
	s = s % 1
print(c)


length = int(input())
moves = 0
while True:
	if length <= 5:
		moves += 1
		break
	else:
		moves += 1
		length -= 5
		continue
print(moves)


def program(n):
	min_step = 0
	steps = [5, 4, 3, 2, 1]
	max_num = steps[0]
	if n >= max_num:
		min_step = n // max_num
		n = n % max_num
	steps.pop(0)
	while n:
		for i in steps:
			if n >= i:
				min_step += 1
				n -= i
				break
	return min_step
n = int(input())
print(program(n))


n = int(input())
step = 0
if n <= 5:
	step = 1
else:
	a = n // 5
	step += a
	rem = n - a * 5
	if rem != 0:
		step += 1
print(step)


goal = int(input())
steps = 0
for step in range(5, 0, -1):
	steps += goal // step
	goal %= step
print(steps)


n = int(input())
if n <= 5:
	print(1)
elif n == 1000000:
	print(200000)
elif n % 5 == 0:
	print(n // 5)
else:
	print(n // 5 + 1)


import math
x = int(input())
s = math.ceil(x / 5)
print(s)


from sys import stdin, stdout
import math
from itertools import permutations, combinations
from collections import defaultdict
from collections import Counter
from bisect import bisect_left
import sys
from queue import PriorityQueue
import operator as op
from functools import reduce
mod = 1000000007

def L():
	return list(map(int, stdin.readline().split()))

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

def I():
	return int(stdin.readline())

def printIn(ob):
	return stdout.write(str(ob) + '\n')

def powerLL(n, p):
	result = 1
	while p:
		if p & 1:
			result = result * n % mod
		p = int(p / 2)
		n = n * n % mod
	return result

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

def isPrime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True

def myCode():
	n = I()
	if n <= 5:
		print(1)
	elif n % 5 == 0:
		print(n // 5)
	else:
		print(n // 5 + 1)

def main():
	myCode()
main()


s = int(input())
t = 0
for _ in (5, 4, 3, 2, 1):
	t += s // _
	s -= s // _ * _
	if s == 0:
		break
print(t)


pontoamigo = int(input())
if pontoamigo % 5 == 0:
	c = pontoamigo // 5
else:
	c = pontoamigo // 5 + 1
print(c)


x = int(input())
y = x
max = 5
steps = 0
while y != 0:
	if y >= max:
		steps += y // max
		y = y % max
	max -= 1
print(steps)


n = int(input().strip())
arr = [5, 4, 3, 2, 1]
ans = 0
for i in arr:
	if n == 0:
		break
	ans += n // i
	n %= i
print(ans)


list1 = [4, 7, 47, 74, 477, 447, 444, 744, 774, 777, 474, 747]
n = int(input())
cou = 0
while n >= 5:
	n -= 5
	cou += 1
while n >= 4:
	n -= 4
	cou += 1
while n >= 3:
	n -= 3
	cou += 1
while n >= 2:
	n -= 2
	cou += 1
while n >= 1:
	n -= 1
	cou += 1
print(cou)


def steps(n):
	steps = 0
	while n > 0:
		if n >= 5:
			steps += 1
			n -= 5
		else:
			steps += 1
			n -= n
	return steps
n = int(input())
print(steps(n))


count = 0
e = 0
x = int(input())
while x - e != 0:
	for i in range(5, 0, -1):
		if x - e >= i:
			e += i
			count += 1
			break
print(count)


n = int(input())
vals = [5, 4, 3, 2, 1]
step = 0
for i in range(len(vals)):
	if n >= vals[i]:
		step += n // vals[i]
		n = n % vals[i]
print(step)


def slon(liczba):
	wynik = 0
	while liczba > 5:
		liczba -= 5
		wynik += 1
	return wynik + 1
print(slon(int(input())))


def main():
	n = int(input())
	print(n // 5 + (1 if n % 5 != 0 else 0))
main()


coordinate = int(input())
if coordinate % 5 == 0:
	print(int(coordinate / 5))
else:
	print(int(coordinate / 5) + 1)


coordination = int(input())
total_steps = 5
if coordination % total_steps == 0:
	minimum = coordination // total_steps
	print(minimum)
else:
	print(coordination // 5 + 1)


from sys import stdin, exit
n = int(stdin.readline().rstrip())
moves_5 = n // 5
n -= moves_5 * 5
moves_4 = n // 4
n -= moves_4 * 4
moves_3 = n // 3
n -= moves_3 * 3
moves_2 = n // 2
n -= moves_2 * 2
total = n + moves_5 + moves_4 + moves_3 + moves_2
print(total)


coord = int(input())
distLeft = int(coord)
moveCount = int(0)
while distLeft != 0:
	if distLeft >= 5:
		distLeft = distLeft - 5
		moveCount += 1
	elif distLeft == 4:
		distLeft = distLeft - 4
		moveCount += 1
	elif distLeft == 3:
		distLeft = distLeft - 3
		moveCount += 1
	elif distLeft == 2:
		distLeft = distLeft - 2
		moveCount += 1
	elif distLeft == 1:
		distLeft = distLeft - 1
		moveCount += 1
print(moveCount)


x = int(input())
toplanacaksayi1 = x // 5
toplanacaksayi2 = x % 5
if toplanacaksayi2 == 0:
	print(toplanacaksayi1)
else:
	print(toplanacaksayi1 + 1)


coordinate = int(input())
if coordinate % 5 == 0:
	a = coordinate // 5
elif coordinate % 5 != 0:
	a = coordinate // 5 + 1
print(a)


def main():
	f = int(input())
	nb_steps = 0
	for i in range(5, 0, -1):
		nb_steps += f // i
		f = f % i
	print(nb_steps, end='')
main()


x = int(input())
steps = [1, 2, 3, 4, 5]
i = 0
(q, r) = divmod(x, max(steps))
if r != 0:
	print(q + 1)
else:
	print(q)


x = int(input())
k = 0
k = x // 5
if x % 5 != 0:
	k = k + 1
print(k)


FriendsHouse = int(input())
steps = 0
if FriendsHouse <= 5:
	print('1')
elif FriendsHouse > 5:
	if FriendsHouse % 5 == 0:
		steps = int(FriendsHouse / 5)
		print(steps)
	else:
		temp_1 = int(FriendsHouse / 5)
		smaller_steps = 1
		steps = temp_1 + smaller_steps
		print(steps)


q = int(input())
print(q // 5 if q == 5 or q % 5 == 0 else q // 5 + 1)


x = int(input())
elephant = []
steps = [5, 4, 3, 2, 1]
for i in range(len(steps)):
	elephant.append(x // steps[i])
	x -= elephant[i] * steps[i]
print(sum(elephant))


d = int(input())
a = [5, 4, 3, 2, 1]
if d in a:
	print(1)
else:
	c = 0
	while d > 0:
		for i in range(5):
			if d >= a[i]:
				d -= a[i]
				c += 1
				break
	print(c)


goal = int(input())
steps = 5
answer = 0
while goal > 0:
	if goal - steps < 0:
		steps -= 1
	goal -= steps
	answer += 1
print(answer)


current = 0
target = int(input())
if current > target:
	temp = target
	target = current
	current = temp
attempts = 0
for factor in [5, 4, 3, 2, 1]:
	attempts += (target - current) // factor
	current += (target - current) // factor * factor
print(attempts)


import math
x = int(input())
a = x % 5
b = a % 4
c = b % 3
d = c % 2
print(x // 5 + a // 4 + b // 3 + c // 2 + d)


position = int(input())
answer = 0
while position >= 1:
	position = position - 5
	answer = answer + 1
print(answer)


x = int(input())
pos = 0
step = 0
while pos != x:
	if x - pos >= 5:
		pos += 5
		step += 1
	else:
		pos += x - pos
		step += 1
print(step)


x = int(input())
cnt = 1
while x > 5:
	x = x - 5
	cnt = cnt + 1
print(cnt)


x = int(input())
steps = [5, 4, 3, 2, 1]
count = 0
for i in range(len(steps)):
	if x >= steps[i]:
		count += x // steps[i]
		x = x % steps[i]
print(count)


x = int(input())
su = 0
a0 = int(x / 5)
su += a0
x -= int(a0 * 5)
a1 = int(x / 4)
su += a1
x -= int(a1 * 4)
a2 = int(x / 3)
su += a2
x -= int(a2 * 3)
a3 = int(x / 2)
su += a3
x -= int(a3 * 2)
print(su + x)


t1 = int(input())
sol = 0
if t1 >= 5:
	k1 = t1 // 5
	sol = sol + k1
	t1 = t1 - 5 * k1
if t1 >= 4:
	k2 = t1 // 4
	sol = sol + k2
	t1 = t1 - 4 * k2
if t1 >= 3:
	k3 = t1 // 3
	sol = sol + k3
	t1 = t1 - 3 * k3
if t1 >= 2:
	k2 = t1 // 2
	sol = sol + k2
	t1 = t1 - 2 * k2
if t1 >= 1:
	k1 = t1 // 1
	sol = sol + k1
	t1 = t1 - 1 * k1
print(sol)


n = int(input())
t = 0
for i in range(5, 0, -1):
	if n % i > 0:
		t += n // i
		n -= n // i * i
		if n == 0:
			break
	elif n % i == 0:
		t += n // i
		break
print(t)


x = int(input())
ilepiatek = x // 5
reszta = x - ilepiatek * 5
if reszta == 0:
	print(ilepiatek)
else:
	print(ilepiatek + 1)


from sys import stdin
m = int(stdin.readline().strip())
if m % 5 != 0:
	print(int(m / 5) + 1)
else:
	print(int(m / 5))


def main():
	n = int(input())
	steps = 0
	div = n // 5
	if div * 5 != n:
		steps = div + 1
	else:
		steps = div
	print(steps)
main()


n = int(input())
x = int(n / 5)
a = int(n % 5)
y = int(a / 4)
b = int(a % 4)
z = int(b / 3)
c = int(b % 3)
p = int(c / 2)
d = int(c % 2)
ans = x + y + z + p + d
print(ans)


x = int(input())
minStep = x // 5
if x % 5 > 0:
	minStep = minStep + 1
print(minStep)


def main(n):
	ans = n // 5
	if n % 5 != 0:
		ans += 1
	return ans
ans = main(int(input()))
print(ans)


n = int(input())
step = [5, 4, 3, 2, 1]
steps = [0, 0, 0, 0, 0]
for i in range(5):
	steps[i] = (n - n % step[i]) // step[i]
	n -= steps[i] * step[i]
print(int(sum(steps)))


poz = int(input())
ans = poz // 5
if poz % 5 != 0:
	ans += 1
print(ans)


number = int(input())
steps = (5, 4, 3, 2, 1)
qtdeSteps = 0
for i in range(len(steps)):
	while number >= steps[i]:
		number = number - steps[i]
		qtdeSteps += 1
print(qtdeSteps)


x = int(input())
c = x // 5
x = x % 5
b = x // 4
x %= 4
d = x // 3
x %= 3
e = x // 2
x %= 2
f = x // 1
print(c + b + d + e + f)


def count_f(inp):
	count = 0
	for i in range(0, inp):
		if inp >= 5:
			count = count + 1
			inp = inp - 5
			continue
		if inp == 4:
			count = count + 1
			inp = inp - 4
			continue
		if inp == 3:
			count = count + 1
			inp = inp - 3
			continue
		if inp == 2:
			count = count + 1
			inp = inp - 2
			continue
		if inp == 1:
			count = count + 1
			inp = inp - 1
			continue
		if inp == 0:
			break
	return count
inp = int(input())
res = count_f(inp)
print(res)


n = int(input())
count = 0
steps = 5
while steps:
	count += n // steps
	n %= steps
	steps -= 1
print(count)


n1 = int(input())
passos5 = n1 // 5
passos4 = (n1 - passos5 * 5) // 4
passos3 = (n1 - passos5 * 5 - passos4 * 4) // 3
passos2 = (n1 - passos5 * 5 - passos4 * 4 - passos3 * 3) // 2
passos1 = (n1 - passos5 * 5 - passos4 * 4 - passos3 * 3 - passos2 * 2) // 1
tot = passos5 + passos4 + passos3 + passos2 + passos1
print(tot)


s = int(input())
u = s // 5
if s % 5 == 0:
	print(u)
else:
	print(u + 1)


n = int(input())
r = n // 5
n %= 5
r += n // 4
n %= 4
r += n // 3
n %= 3
r += n // 2
n %= 2
r += n // 1
n %= 1
print(r)


n = int(input())
t = 0
i = 5
while n:
	a = n // i
	t = t + a
	n = n % i
	i = i - 1
print(t)


i = int(input())
p = i // 5
if i % 5 > 0:
	p = p + 1
print(p)


from heapq import heappush, heappop
import queue
import re

def int_raw():
	return int(input())

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

def ints_raw():
	return list(map(int, ss_raw()))
INF = 1 << 29

def make1d_arr(n, val=INF):
	return [val for i in range(n)]

def make2d_arr(h, w, val=INF):
	return [[val for i in range(w)] for i in range(h)]
x = int_raw()

def main():
	return (x + 4) // 5
print(main())


x = int(input().strip())
if x % 5 == 0:
	print(x // 5)
elif x % 5 > 2:
	print(x // 5 + 1)
else:
	print(x // 5 + 1)


ele_frd = int(input())
res = ele_frd // 5
r = ele_frd % 5
if r == 0:
	print(res)
else:
	print(res + 1)


k = int(input())
l = k // 5
m = k % 5
if m > 0:
	print(l + 1)
else:
	print(l)


n = int(input())
i = 5
t = 0
while True:
	if n >= i:
		t += n // i
		n %= i
	else:
		i -= 1
	if n == 0:
		break
print(t)


n = int(input())
steps = 0
rem = 0
if n >= 5:
	rem = n % 5
	steps += n // 5
	n = 0
if rem > 0 or n > 0:
	steps += 1
print(steps)


x = int(input())
varOne = x // 5
remainderOne = x % 5
varTwo = remainderOne // 4
remainderTwo = remainderOne % 4
varThree = remainderTwo // 3
remainderThree = remainderTwo % 3
varFour = remainderThree // 2
remainderFour = remainderThree % 2
varFive = remainderFour // 1
answer = varOne + varTwo + varThree + varFour + varFive
print(answer)


a = int(input())
count = 0
t = 0
while t < a:
	for i in reversed(range(1, 6)):
		count += 1
		t += i
		break
print(count)


a = int(input())
b = a - 5 * (a // 5)
b1 = a // 5
c = b - 4 * (b // 4)
c1 = b // 4
d = c - 3 * (c // 3)
d1 = c // 3
e = d - 2 * (d // 2)
e1 = d // 2
f = e - 1 * (e // 1)
f1 = e // 1
r = b1 + c1 + d1 + e1 + f1
print(r)


steps = int(input())
result = steps // 5
if steps % 5 != 0:
	result += 1
print(result)


import math
Distanz = int(input())
Schritte = 0
for i in range(5):
	Schritte += math.floor(Distanz / (5 - i))
	Distanz = Distanz % (5 - i)
print(Schritte)


f_pos = int(input())
if f_pos % 5 == 0:
	print(int(f_pos / 5))
else:
	print(f_pos // 5 + 1)


n = int(input())
result = 0
l = [5, 4, 3, 2, 1]
for i in range(5):
	result = result + n // l[i]
	n = n % l[i]
	if n == 0:
		break
print(result)


n = int(input())
s = 0
a = n / 5
b = n % 5
c = b / 4
d = b % 4
e = d / 3
f = d % 3
g = f / 2
h = f % 2
i = h / 1
s = int(a) + int(c) + int(e) + int(g) + int(i)
print(s)


x = int(input())
c = int((x + 4) / 5)
print(c)


x = int(input())
buoc5 = x // 5
if x % 5 > 0:
	buoc5 = buoc5 + 1
print(buoc5)


n = int(input())
t = n

def solve(n, s):
	if n == 0:
		return s
	if n <= 5:
		return s + 1
	else:
		return solve(n % 5, n // 5 + s)
print(solve(t, 0))


n = int(input())
src = 0
cn = 0
while src != n:
	if n - src > 5:
		cn += 1
		src += 5
	else:
		cn += 1
		src += n - src
print(cn)


import math

def main():
	coord = int(input())
	steps = coord / 5
	steps = math.ceil(steps)
	print(int(steps))
main()


from sys import stdin, stdout

def get_int():
	return int(stdin.readline().strip())

def main():
	write = stdout.write
	x = get_int()
	steps = [5, 4, 3, 2, 1]
	index = 0
	ans = 0
	while x != 0:
		if x - steps[index] < 0:
			index += 1
			continue
		x -= steps[index]
		ans += 1
	write(str(ans))
	pass
main()


travel = int(input())
steps = [5, 4, 3, 2, 1]
steps_taken = 0
for step in steps:
	while travel >= step:
		travel -= step
		steps_taken += 1
print(steps_taken)


x = int(input())
xby5 = x // 5
x = x - xby5 * 5
xby4 = x // 4
x = x - xby4 * 4
xby3 = x // 3
x = x - xby3 * 3
xby2 = x // 2
x = x - xby2 * 2
xby1 = x // 1
x = x - xby1 * 1
print(xby5 + xby4 + xby3 + xby2 + xby1)


n = int(input())
st = [1, 2, 3, 4, 5]
res = 0
while n > 0:
	if n >= st[4]:
		n = n - st[4]
		res += 1
		continue
	elif n >= st[3]:
		n = n - st[3]
		res += 1
		continue
	elif n >= st[2]:
		n = n - st[2]
		res += 1
		continue
	elif n >= st[1]:
		n = n - st[1]
		res += 1
		continue
	elif n >= st[0]:
		n = n - st[0]
		res += 1
		continue
print(res)


a = input()
a = int(a)
number = 0
step = [5, 4, 3, 2, 1]
while a - 5 > 0 or a - 5 == 0:
	a = a - 5
	number = number + 1
while a - 4 > 0 or a - 4 == 0:
	a = a - 4
	number = number + 1
while a - 3 > 0 or a - 3 == 0:
	a = a - 3
	number = number + 1
while a - 2 > 0 or a - 2 == 0:
	a = a - 2
	number = number + 1
while a - 1 > 0 or a - 1 == 0:
	a = a - 1
	number = number + 1
print(number)


x = int(input())
a = [5, 4, 3, 2, 1]
hasil = 0
for i in a:
	if x >= i:
		hasil += x // i
		x = x % i
print(hasil)


x = int(input())
lst = [5, 4, 3, 2, 1]
step = 0
step1 = 0
step2 = 0
for i in lst:
	if x >= 5:
		step1 = int(x / 5)
		rest = x % 5
		x = rest
		if x == 0:
			step = step1
			break
	elif x % i == 0:
		step2 = int(x / i)
		rest = x % i
		step = step1 + step2
		if rest == 0:
			break
print(step)


def elephant_moves():
	move = int(input())
	if move == 0:
		print(0)
		return
	elif move <= 5:
		print(1)
		return
	if move % 5 == 0:
		print(int(move / 5))
	else:
		print(int(move / 5) + 1)
elephant_moves()


n = int(input())
count = 0
for i in range(0, n):
	if n == 5:
		count = count + 1
		n = n - 5
	elif n == 4:
		count = count + 1
		n = n - 4
	elif n == 3:
		count = count + 1
		n = n - 3
	elif n == 2:
		count = count + 1
		n = n - 2
	elif n == 1:
		count = count + 1
		n = n - 1
	elif n > 5:
		n = n - 5
		count = count + 1
	elif n == 0:
		break
print(count)


def main():
	x = int(input())
	ans = x // 5 + (1 if x % 5 > 0 else 0)
	print(ans)
while True:
	try:
		main()
	except EOFError:
		break


c = int(input())
if c % 5 > 0:
	d = 1
else:
	d = 0
print(c // 5 + d)


n = int(input())
nums = [1, 2, 3, 4, 5]
count = 0
while True:
	x = 4
	if n in nums:
		count += 1
		break
	else:
		n -= nums[x]
		if n > 0:
			count += 1
		else:
			break
		x -= 1
print(count)


x = int(input())
nb = x // 5
if x % 5 != 0:
	nb += 1
print(nb)


get = int(input())
out = 0
out = (get + 4) // 5
print(out)


a = int(input())
r = a % 5
p = int(a / 5)
if r % 4 == 0:
	q = int(r / 4)
elif r % 3 == 0:
	q = int(r / 3)
elif r % 2 == 0:
	q = int(r / 2)
elif r % 1 == 0:
	q = int(r / 1)
print(p + q)


x = int(input())
i = 0
i += x // 5
x = x % 5
i += x // 4
x = x % 4
i += x // 3
x = x % 3
i += x // 2
x = x % 2
i += x
print(i)


a = int(input())
b = int(a / 5)
bx = a % 5
c = int(bx / 4)
cx = bx % 4
d = int(cx / 3)
dx = cx % 3
e = int(dx / 2)
ex = dx % 2
f = int(ex / 1)
print(b + c + d + e + f)


x = int(input())
if x > 0 and x <= 5:
	print('1')
if x > 5:
	odd = x % 5
	if odd > 0 and odd <= 5:
		step = int(x / 5) + 1
		print(step)
	if odd == 0:
		step = int(x / 5)
		print(step)


x = int(input())
count = 0
if x > 5:
	count += round(x / 5 - 0.5)
	x -= count * 5
	if x == 0:
		print(count)
	else:
		print(count + 1)
else:
	print(1)


n = int(input())
m = 0
m = m + n // 5
n = n % 5
m = m + n // 4
n = n % 4
m = m + n // 3
n = n % 3
m = m + n // 2
n = n % 2
m = m + n // 1
n = n % 1
print(m)


from math import ceil
posicion = int(input())
pasos = ceil(posicion / 5)
print(pasos)


import math
a = int(input())
b = [1, 2, 3, 4, 5]
f = []
for i in b:
	f.append(math.ceil(a / i))
print(min(f))


l = [5, 4, 3, 2, 1]
n = int(input())
c = 0
while n > 0:
	for i in l:
		if n - i >= 0:
			n = n - i
			c = c + 1
			break
		else:
			pass
print(c)


n = int(input())
count = 0
five = int(n / 5)
if five > 0:
	n -= five * 5
	count += five
four = int(n / 4)
if four > 0:
	n -= four * 4
	count += four
three = int(n / 3)
if three > 0:
	n -= three * 3
	count += three
two = int(n / 2)
if two > 0:
	n -= two * 2
	count += two
one = int(n / 1)
if one > 0:
	n -= one * 4
	count += one
print(count)


from __future__ import division, print_function
import itertools, os, sys, threading
from collections import deque, Counter, OrderedDict, defaultdict
import heapq
from math import ceil, floor, log, sqrt, factorial, pow, pi, gcd

def ii():
	return int(input())

def si():
	return str(input())

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

def li():
	return list(mi())
abc = 'abcdefghijklmnopqrstuvwxyz'
abd = {'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod = 1000000007
(dx, dy) = ([-1, 1, 0, 0], [0, 0, 1, -1])

def getKey(item):
	return item[0]

def sort2(l):
	return sorted(l, key=getKey)

def d2(n, m, num):
	return [[num for x in range(m)] for y in range(n)]

def isPowerOfTwo(x):
	return x and (not x & x - 1)

def decimalToBinary(n):
	return bin(n).replace('0b', '')

def ntl(n):
	return [int(i) for i in str(n)]

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

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x
graph = defaultdict(list)
visited = [0] * 1000000
col = [-1] * 1000000

def dfs(v, c):
	if visited[v]:
		if col[v] != c:
			print('-1')
			exit()
		return
	col[v] = c
	visited[v] = 1
	for i in graph[v]:
		dfs(i, c ^ 1)

def bfs(d, v):
	q = []
	q.append(v)
	visited[v] = 1
	while len(q) != 0:
		x = q[0]
		q.pop(0)
		for i in d[x]:
			if visited[i] != 1:
				visited[i] = 1
				q.append(i)
		print(x)
	print(l)

def make_graph(e):
	d = {}
	for i in range(e):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
		if y not in d.keys():
			d[y] = [x]
		else:
			d[y].append(x)
	return d

def gr2(n):
	d = {}
	for i in range(n):
		(x, y) = mi()
		if x not in d.keys():
			d[x] = [y]
		else:
			d[x].append(y)
	return d

def connected_components(graph):
	seen = set()

	def dfs(v):
		vs = set([v])
		component = []
		while vs:
			v = vs.pop()
			seen.add(v)
			vs |= set(graph[v]) - seen
			component.append(v)
		return component
	ans = []
	for v in graph:
		if v not in seen:
			d = dfs(v)
			ans.append(d)
	return ans
n = ii()
x = n // 5
if n % 5 == 0:
	print(x)
	exit()
print(x + 1)


x = int(input())
1 <= x <= 1000000
if x % 5 == 0:
	min = x // 5
else:
	min = x // 5 + 1
print(min)


Spaces = int(input())
Turns = 0
while Spaces > 0:
	Spaces -= 5
	Turns += 1
print(Turns)


point = int(input())
lst = [5, 4, 3, 2, 1]
steps = 0
for num in lst:
	steps += int(point / num)
	point = point % num
	if point == 0:
		break
print(steps)


distance = int(input())
steps = 0
while True:
	if distance > 5:
		distance -= 5
		steps += 1
	else:
		steps += 1
		break
print(steps)


d = int(input().strip())
count = 0
while True:
	if d >= 5:
		count += 1
		d -= 5
	elif d >= 4:
		count += 1
		d -= 4
	elif d >= 3:
		count += 1
		d -= 3
	elif d >= 2:
		count += 1
		d -= 2
	elif d >= 1:
		count += 1
		d -= 1
	if d == 0:
		print(count)
		break


d = [int(i) for i in input().split()][0]
if d <= 5:
	print(1)
elif d % 5 == 0:
	print(d // 5)
else:
	print(d // 5 + 1)


n = int(input())
s1 = int(n / 5)
if s1 >= 1:
	n = n - s1 * 5
s2 = int(n / 4)
if s2 >= 1:
	n = n - s2 * 4
s3 = int(n / 3)
if s3 >= 1:
	n = n - s3 * 3
s4 = int(n / 2)
if s4 >= 1:
	n = n - s4 * 2
s5 = int(n / 1)
if s5 >= 1:
	n = n - s5 * 1
s = s1 + s2 + s3 + s4 + s5
print(s)


coordinate = int(input())
steps = coordinate // 5
if coordinate % 5 != 0:
	steps += 1
print(steps)


x = int(input())
c = 0
k = 0
c += x // 5
x = x % 5
c += x // 4
x = x % 4
c += x // 3
x = x % 3
c += x // 2
x = x % 2
c += x // 1
print(c)


import math
dis = int(input(''))
steps = [5, 4, 3, 2, 1]
dis_by_step = []
for step in steps:
	dis_by_step.append(math.ceil(dis / step))
print(dis_by_step[0])


x = int(input())
ans = x // 5 + int(not x % 5 == 0)
print(ans)


n = int(input())
turns = 0
while n > 0:
	for i in range(5, 0, -1):
		if n >= i:
			n -= i
			turns += 1
			break
print(turns)


dis_remaining = int(input())
num_of_steps = int(0)
for i in reversed(range(1, 6)):
	num_of_steps += dis_remaining // i
	dis_remaining = dis_remaining % i
print(num_of_steps)


x = int(input())
steps = 0
if x > 5:
	a = x / 5
	(b, c) = str(a).split('.')
	b = int(b)
	c = int(c)
	add = 0
	if c > 0:
		add = 1
	steps = steps + b + add
else:
	steps += 1
print(steps)


n = int(input())
co = 0
if n >= 5:
	a = n // 5
	n = n % 5
	co = co + a
print(co + 1) if n != 0 else print(co)


def cal_moves(distance):
	if distance <= 5:
		print(1)
	else:
		moves = 0
		while distance != 0:
			arr = [5, 4, 3, 2, 1]
			for i in range(0, len(arr)):
				if distance >= arr[i]:
					distance = distance - arr[i]
					moves += 1
					break
		print(moves)
distance = int(input())
cal_moves(distance)


import math
x = int(input())
if x % 5 == 0:
	c = x / 5
	print(int(c))
else:
	print(math.ceil(x / 5))


n = int(input())
s = int(n / 5)
n %= 5
s += int(n / 4)
n %= 4
s += int(n / 3)
n %= 3
s += int(n / 2)
s += n % 2
print(s)


inp = int(input())
count = 0
if inp > 0:
	s1 = int(inp / 5)
	count = count + s1
	inp = inp - 5 * s1
	s2 = int(inp / 4)
	count = count + s2
	inp = inp - 4 * s2
	s3 = int(inp / 3)
	count = count + s3
	inp = inp - 3 * s3
	s4 = int(inp / 2)
	count = count + s4
	inp = inp - 2 * s4
	s5 = int(inp / 1)
	count = count + s5
	inp = inp - 1 * s5
	print(count)


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 solve():
	n = int(input())
	print(math.ceil(n / 5))
for _ in range(1):
	solve()


n = int(input())
counter = 1
while n > 5:
	n -= 5
	counter += 1
print(counter)


n = int(input())
f = 0
while n != 0:
	if n > 5:
		f += n // 5
		n = n % 5
	else:
		f += 1
		n = 0
print(f)


def steps(num):
	steps = 0
	if num >= 5:
		steps = steps + int(num / 5)
		num = num % 5
	if num >= 4:
		steps = steps + int(num / 4)
		num = num % 4
	if num >= 3:
		steps = steps + int(num / 3)
		num = num % 3
	if num >= 2:
		steps = steps + int(num / 2)
		num = num % 2
	if num >= 1:
		steps = steps + int(num / 1)
		num = num % 1
	return steps
location = int(input())
if location <= 5:
	print(1)
else:
	print(steps(location))


x = int(input())
if x <= 5 and x >= 1:
	print('1')
elif x > 5:
	x = float(x)
	z = (x + 4) / 5
	z = int(z)
	print(z)


dist = int(input())
temp = dist % 5
ans = dist // 5
if temp > 0:
	ans += 1
print(ans)


from sys import stdin
_input = stdin.readline
_int = int

def solution():
	n = _int(_input())
	ans = n // 5
	if n % 5 > 0:
		ans += 1
	print(ans)
solution()


x = int(input())
moegl_schritte = [5, 4, 3, 2, 1]
minimal = 0
for schritt in moegl_schritte:
	anzahl = int(x / schritt)
	x -= anzahl * schritt
	minimal += anzahl
	if x == 0:
		break
print(minimal)


s = int(input())
res = s % 5
ans = s // 5
if res == 0:
	print(ans)
else:
	print(ans + 1)


n = int(input())
d = n // 5
if n % 5 != 0:
	d += 1
print(d)


x = int(input())
ans = 0
l = [5, 4, 3, 2, 1]
j = 0
while x >= 0 and j < 5:
	ans = ans + x // l[j]
	x = x % l[j]
	j += 1
print(ans)


print(abs(-int(input()) // 5))


y = int(input())
x = y
step = 0
while x != 0:
	if x >= 5:
		x = x - 5
		step = step + 1
	elif x >= 4:
		x = x - 4
		step = step + 1
	elif x >= 3:
		x = x - 3
		step = step + 1
	elif x >= 2:
		x = x - 2
		step = step + 1
	elif x > 1:
		x = x - 1
		step = step + 1
	elif x == 1:
		step = step + 1
		x = 0
		break
print(step)


friend_coord = int(input())
if friend_coord % 5 == 0:
	print(int(friend_coord / 5))
else:
	print(int(friend_coord / 5) + 1)


import math
x = int(input())
step = 0
while x != 0:
	for i in range(5, 0, -1):
		if x >= i:
			step += math.floor(x / i)
			x = x % i
print(step)


x = int(input())
y = 0
c = 0
while y < x:
	if y + 5 > x:
		y += x - y
	else:
		y += 5
	c += 1
print(c)


hat = int(input())
if hat % 5 != 0:
	print(int(hat / 5) + 1)
else:
	print(int(hat / 5))


import math
dis = int(input())
print(math.ceil(dis / 5))


import math
import sys
import cmath
import string
import bisect
from itertools import combinations, permutations
from queue import Queue, LifoQueue, PriorityQueue
from collections import deque, Counter
n = int(input())
count = 0
s = [5, 4, 3, 2, 1]
for i in range(5):
	if n >= s[i]:
		temp = n // s[i]
		count += temp
		n -= temp * s[i]
print(count)


x = int(input())
div = x // 5
mod = x % 5
if mod == 0:
	print(div)
else:
	print(div + 1)


import math
num = float(input())
if (num / 5).is_integer():
	print(int(num / 5))
else:
	print(int(math.ceil(num / 5)))


x = int(input())
s = x // 5
x = x - s * 5
if x % 10 > 0:
	s = s + 1
print(s)


n = int(input())
a = ['5', '4', '3', '2', '1']
j = 0
count = 0
for i in a:
	if n >= int(i):
		j = n // int(i)
		n = n - j * int(i)
		count += j
print(count)


x = int(input())
ma = [5, 4, 3, 2, 1]
steps = 0
for y in ma:
	q = x // y
	r = x % y
	steps += q
	x = r
print(steps)


n = int(input())
if n % 5 == 0:
	print(n // 5)
else:
	out = n // 5
	print(out + 1)


n = int(input())
s = 0
t = n
if n == 5 or n == 4 or n == 3 or (n == 2) or (n == 1):
	print(1)
else:
	x = n % 5
	if t != x:
		s = s + n / 5
	t = x
	y = x % 4
	if t != y:
		s = s + x / 4
	t = y
	z = y % 3
	if t != z:
		s = s + y / 3
	t = z
	q = z % 2
	if t != q:
		s = s + z / 2
	t = q
	w = q % 1
	if t != w:
		s = s + q / 1
	t = w
if s > 0:
	print(int(s))


inp = int(input())
li = [1, 2, 3, 4, 5]
counter = 0
check = 0
i = len(li) - 1
while check < inp:
	if li[i] == inp:
		counter += 1
		break
	elif li[i] < inp:
		counter += 1
		check += li[i]
	else:
		i -= 1
print(counter)


import math as M
n = int(input())
print(M.ceil(n / 5))


x = int(input())
a = x % 5
c1 = int(x / 5)
b = a % 4
c2 = int(a / 4)
c = b % 3
c3 = int(b / 3)
d = c % 2
c4 = int(c / 2)
e = d % 1
c5 = int(d / 1)
print(c1 + c2 + c3 + c4 + c5)


def countSteps(X):
	count = 0
	l = [1, 2, 3, 4, 5]
	n = len(l)
	while X > l[n - 1]:
		X = X - l[n - 1]
		count = count + 1
	if X in l:
		count = count + 1
	return count
x = int(input())
res = countSteps(x)
print(res)


n = int(input())
c = n // 5
if n % 5 == 0:
	pass
else:
	c += 1
print(c)


step = int(input())
one = step // 5
two = step % 5 // 4
three = step % 5 % 4 // 3
four = step % 5 % 4 % 3 // 2
five = step % 5 % 4 % 3 % 2 // 1
print(one + two + three + four + five)


import math
distance = int(input())
steps = math.floor(distance / 5)
if distance % 5 == 0:
	print(steps)
else:
	print(steps + 1)


inp = int(input())

def elephant(n):
	m = 0
	div = 5
	while div > 0:
		if n >= div:
			n = n - div
			m += 1
		else:
			div -= 1
	print(m)
elephant(inp)


x = int(input())
if x < 6:
	print(1)
else:
	print(x // 5 + (1 if x % 5 != 0 else 0))


z = int(input())
additional = z % 5
if additional == 0:
	additional = 0
else:
	additional = 1
print(z // 5 + additional)


def m(a, b):
	return a % b
n = int(input())
stp = 0
for i in range(5, 0, -1):
	stp += n // i
	n = m(n, i)
print(stp)


n = int(input())
x = 0
steps = 0
while x < n:
	x += 5
	steps += 1
print(steps)


x = int(input())
step = 1
while True:
	if x > 5:
		x -= 5
		step += 1
	else:
		break
print(step)


x = int(input())
ct = 0
ct += x // 5
x = x % 5
ct += x // 4
x = x % 4
ct += x // 3
x = x % 3
ct += x // 2
x = x % 2
ct += x
print(ct)


l = [5, 4, 3, 2, 1]
n = int(input())
c = 0
i = 0
while i < 5 and n != 0:
	b = n // l[i]
	n = n - b * l[i]
	c = c + b
	i = i + 1
print(c)


girdi = int(input())
i = 0
while girdi > 0:
	if girdi > 5:
		girdi -= 5
	else:
		girdi = 0
	i += 1
print(i)


import math
x = int(input())
x = math.ceil(float(x) / 5)
print(x)


import sys
n = int(input())
steps = 0
counter = n // 5
steps += counter
n -= counter * 5
counter = n // 4
steps += counter
n -= counter * 4
counter = n // 3
steps += counter
n -= counter * 3
counter = n // 2
steps += counter
n -= counter * 2
counter = n // 1
steps += counter
n -= counter * 1
print(steps)


n = int(input())
c = 0
x = 0
while x != n:
	c += 1
	if x + 5 <= n:
		x += 5
		continue
	if x + 4 <= n:
		x += 4
		continue
	if x + 3 <= n:
		x += 3
		continue
	if x + 2 <= n:
		x += 2
		continue
	if x + 1 <= n:
		x += 1
		continue
print(c)


home = int(input())
steps = [5, 4, 3, 2, 1]
min_step = 0
i = 0
while home != 0:
	home = home - steps[i]
	if home < 0:
		home = home + steps[i]
		i += 1
	else:
		min_step += 1
print(min_step)


minv = 1 << 343
from math import *
n = int(input())
for i in range(1, 6):
	if not n % i:
		minv = min(minv, n // i)
	else:
		minv = min(minv, int(ceil(n / i)))
print(minv)


steps = [1, 2, 3, 4, 5]
x = int(input())

def countSteps(x):
	count = 0
	while x >= 5:
		count = count + 1
		x = x - 5
	while x >= 4:
		count = count + 1
		x = x - 4
	while x >= 3:
		count = count + 1
		x = x - 3
	while x >= 2:
		count = count + 1
		x = x - 2
	while x >= 1:
		count = count + 1
		x = x - 1
	return count
print(countSteps(x))


n = int(input())
c = 5
ans = 0
while n:
	ans += n // c
	n = n % c
	c -= 1
print(ans)


x = 0
x = int(input())
z = x // 5
if x / 5 - x // 5:
	z += 1
print(z)


import math
x = int(input())
a = [1, 2, 3, 4, 5]
print(min(list(map(lambda a: math.ceil(x / a), a))))


x = int(input())
n = 0
am = 0
while True:
	for i in range(x):
		if n + 5 <= x:
			n += 5
			am += 1
	if n == x:
		break
	for i in range(x):
		if n + 4 <= x:
			n += 4
			am += 1
	if n == x:
		break
	for i in range(x):
		if n + 3 <= x:
			n += 3
			am += 1
	if n == x:
		break
	for i in range(x):
		if n + 2 <= x:
			n += 2
			am += 1
	if n == x:
		break
	for i in range(x):
		if n + 1 <= x:
			n += 1
			am += 1
	if n == x:
		break
print(am)


x = int(input())
tedad = 0
while x >= 5:
	x -= 5
	tedad += 1
while x == 4:
	x -= 4
	tedad += 1
while x == 3:
	x -= 3
	tedad += 1
while x == 2:
	x -= 2
	tedad += 1
while x == 1:
	x -= 1
	tedad += 1
print(tedad)


t = int(input())
(k, l) = ([1, 2, 3, 4, 5], 0)
for i in range(4, -1, -1):
	if k[i] < t and t > -1:
		if t >= 2 * k[i]:
			l += t // k[i]
			t %= k[i]
		else:
			l += 1
			t %= k[i]
	if k[i] == t and t > -1:
		l += t // k[i]
		t %= k[i]
print(l)


out = 0
stp = int(input())
if stp <= 5:
	print('1')
elif stp % 5 == 0:
	out = stp / 5
	print(int(out))
elif stp > 5 and stp % 5 != 0:
	out = stp / 5 + 1
	print(int(out))


x = int(input())
moves = 0
while x > 5:
	x -= 5
	moves += 1
moves += 1
print(moves)


x = int(input())
ans = 0
i = 0
while ans < x:
	ans += 5
	i += 1
print(i)


n = int(input())
print(n // 5 + (1 if n % 5 is not 0 else 0))


d = int(input())
q = d // 5
r = d % 5
if r != 0:
	s = q + 1
else:
	s = q
print(s)


N = int(input())
u = 5
pasos = int(0)
while N != 0:
	if N < u:
		u = u - 1
	else:
		pasos = pasos + N / u
		N = N % u
print(int(pasos))


import math
n = int(input())
steps = math.ceil(n / 5)
print(steps)


n = int(input())
i = 5
ans = 0
while n > 0:
	ans += n // i
	n -= i * (n // i)
	i -= 1
print(ans)


x = int(input())
i = 5
n = 0
while i > 0 and x % i >= 0:
	n = n + x // i
	x = x % i
	i -= 1
print(n)


distance = int(input())
steps = 0
x = 5
count = 0
for i in range(0, 5):
	while distance > steps:
		steps = steps + x
		count += 1
	x -= 1
print(count)


d = int(input())
step = 0
while d > 0:
	if d // 5 > 0:
		d -= 5
	else:
		d -= d
	step += 1
print(step)


a = int(input())
d = [5, 4, 3, 2, 1]
i = 0
cnt = 0
while a != 0:
	if a >= d[i]:
		a = a - d[i]
		cnt += 1
	else:
		i += 1
print(cnt)


distance = int(input())
tmp = distance // 5
if tmp == 0:
	print(1)
elif distance % 5 == 0:
	print(tmp)
else:
	print(tmp + 1)


n = int(input())
c = 0
i = 5
while i > 0:
	while n >= i:
		c += n // i
		n = n % i
	i -= 1
print(c)


n = int(input())
min_step = 0
for s in [5, 4, 3, 2, 1]:
	min_step += int(n / s)
	n = n % s
print(min_step)


n = int(input())
a = n // 5
a1 = n % 5
b = a1 // 4
b1 = a1 % 4
c = b1 // 3
c1 = b1 % 3
d = c1 // 2
d1 = c1 % 2
s = a + b + c + d + d1
print(s)


n = input()
n = int(n)
s = 0
while n > 0:
	s = s + int(n / 5)
	n = n % 5
	s = s + int(n / 4)
	n = n % 4
	s = s + int(n / 3)
	n = n % 3
	s = s + int(n / 2)
	n = n % 2
	s = s + n
	n = 0
print(s)


from sys import stdin
n = int(stdin.readline())
count = 0
for s in [5, 4, 3, 2, 1]:
	count += n // s
	n %= s
print(count)


x = int(input())
ans = 0
for num in range(5, 0, -1):
	if x % num >= 0 and num <= x:
		ans += x // num
		x %= num
	if x == 0:
		break
print(ans)


x = input()
x = int(x)
l = [5, 4, 3, 2, 1]
sum = 0
for n in l:
	sum = sum + x // n
	x = x % n
print(sum)


from sys import stdin
n = int(stdin.readline().strip())
x = 0
if n % 5 == 0:
	print(n // 5)
else:
	x = n // 5
	n = n % 5
if n == 1:
	x = x + 1
	print(x)
elif n == 2:
	x = x + 1
	print(x)
elif n == 3:
	x = x + 1
	print(x)
elif n == 4:
	x = x + 1
	print(x)


x = int(input())
s = 0
p = int(x / 5)
s += p
if x % 5 != 0:
	x = x % 5
	p = int(x / 4)
	s += p
	if x % 4 != 0:
		x = x % 4
		p = int(x / 3)
		s += p
		if x % 3 != 0:
			x = x % 3
			p = int(x / 2)
			s += p
			if x % 2 != 0:
				x = x % 2
				p = int(x / 1)
				s += 1
print(s)


n = int(input())
c = 0
for k in range(5, 0, -1):
	x = n // k
	c += x
	n = n % k
print(c)


x = int(input())

def g(x):
	k = 0
	if x > 5:
		q = x // 5
		r = x % 5
		k = q
		if r == 0:
			return k
		if r <= 5:
			return k + 1
		else:
			g(r)
	else:
		return k + 1
print(g(int(x)))


(a, b) = divmod(int(input()), 5)
print(a + [0, 1][b > 0])


a = int(input())
r = a % 5
a = a - r
d = a / 5
if r == 0:
	print(int(d))
else:
	print(int(d + 1))


x = int(input())
(step, count) = (5, 0)
while x > 0:
	if x >= step:
		count += x // step
		x = x % step
	step -= 1
print(count)


target = int(input())
if target % 5 == 0:
	move = int(target / 5)
else:
	move = int(target / 5) + 1
print(move)


import math as M
n = int(input())
step = 0
for i in reversed(range(6)):
	step += M.floor(n / i)
	n = n - M.floor(n / i) * i
	if n == 0:
		break
print(step)


x = int(input())
i = 5
counter = 0

def move(i, x, counter):
	while x >= i:
		counter += 1
		x -= i
		if x == 0:
			print(counter)
			quit()
	move(i - 1, x, counter)
print(move(i, x, counter))


afstand = int(input())
max_stap = 5
aantal = afstand // max_stap
rest = afstand % max_stap
if rest > 0:
	aantal += 1
print(aantal)


x = int(input())
if x <= 5:
	print('1')
else:
	val = x // 5
	x = x % 5
	if x > 0:
		print(val + 1)
	else:
		print(val)


distance = int(input())
count = 1
while distance > 5:
	count += 1
	distance -= 5
print(count)


dist = int(input())
steps = 0
stepcount = [x for x in range(1, 6)]
val = -1
while dist >= 1:
	steps += dist // stepcount[val]
	dist %= stepcount[val]
	val -= 1
print(steps)


moves = [4, 3, 2, 1]
x = int(input())
cnt = 0
cnt += x // 5
x = x % 5
for move in moves:
	cnt += x // move
	x = x % move
print(cnt)


n = int(input())
nbr = n // 5
if n % 5 > 0:
	nbr += 1
print(nbr)


a = int(input())
answer = a // 5
a = a - 5 * (a // 5)
answer += a // 4
a = a - 4 * (a // 4)
answer += a // 3
a = a - 3 * (a // 3)
answer += a // 2
a = a - 2 * (a // 2)
answer += a // 1
a = a - 1 * (a // 1)
print(str(int(answer)))


pos = int(input())
print(int(pos / 5) if pos % 5 == 0 else int(pos / 5 + 1))


dist = int(input())
steps = [5, 4, 3, 2, 1]
no_of_steps = 0
i = 0
while dist > 0:
	no_of_steps += int(dist / steps[i])
	dist = dist - steps[i] * int(dist / steps[i])
	i += 1
print(no_of_steps)


x = int(input())
t = x // 5
r = x % 5
if r > 0:
	t += 1
print(t)


s = int(input())
steps = 0
for i in range(5, 0, -1):
	steps += s // i
	s %= i
print(steps)


a = int(input())
k = 0
l = a // 5
k = k + l
a = a - l * 5
s = a // 4
k = k + s
a = a - s * 4
j = a // 3
k = k + j
a = a - j * 3
m = a // 2
k = k + m
a = a - m * 2
b = a // 1
k = k + b
a = a - b * 1
print(k)


x = int(input())
dist = 0
pasos = 0
while dist < x:
	dist += 5
	pasos += 1
print(pasos)


inp = int(input())
x = 0
if inp <= 5:
	print(1)
else:
	x = inp / 5
	if x % 1 * 10 == 0:
		print(int(x))
	else:
		print(int(x + 1))


x = int(input())
a = x // 5
k = x % 5
if k == 0:
	print(a)
else:
	print(a + 1)


def seperateints(x):
	k = ''
	l = []
	for i in x:
		if i == ' ':
			l.append(int(k))
			k = ''
			continue
		k = k + i
	l.append(int(k))
	return l

def luckynum(x):
	for i in x:
		if i != '4' and i != '7':
			return False
	return True
n = int(input())
if n % 5 == 0:
	print(n // 5)
else:
	print(n // 5 + 1)


d = int(input())
print(d // 5 + int(d % 5 > 0))


def solution():
	n = int(input())
	steps = [5, 4, 3, 2, 1]
	count = 0
	for i in range(len(steps)):
		if n >= steps[i]:
			count += n // steps[i]
			n %= steps[i]
	print(count)
solution()


lista = [5, 4, 3, 2, 1]
x = int(input())
total = 0
for i in lista:
	if x >= i:
		result = x // i
		total += result
		remainder = x % i
		x = remainder
print(total)


coordinate = int(input())
if coordinate % 5:
	res = int(coordinate / 5) + 1
else:
	res = int(coordinate / 5)
print(res)


home = int(input())

def good_sol():
	global home
	min_step = 0
	five_count = home // 5
	if five_count != 0:
		min_step = min_step + five_count
		home = home - 5 * five_count
		min_step = min_step + (home % 5 != 0)
	else:
		min_step = min_step + 1
	print(min_step)
good_sol()


house_coord = int(input())
steps = 0
current_coord = 0
while current_coord != house_coord:
	if house_coord - current_coord >= 5:
		current_coord = current_coord + 5
	else:
		current_coord = house_coord
	steps = steps + 1
print(steps)


eingabe = int(input())
teil = eingabe / 5
rest = eingabe % 5
rester = 0
if rest > 0:
	rester = 1
else:
	pass
print(int(teil + rester))


n = int(input())
ctr = 0
while n >= 5:
	n = n - 5
	ctr = ctr + 1
if n > 0:
	ctr = ctr + 1
print(ctr)


n = int(input())
steps = [5, 4, 3, 2, 1]
total = 0
for s in steps:
	total += n // s
	n = n % s
	if not n:
		break
print(total)


n = int(input())
if n < 6:
	print('1')
elif n % 5 == 0:
	print(int(n / 5))
else:
	kq = n // 5 + 1
	print(kq)


x = int(input())
P1 = x // 5
P2 = x % 5 // 4
A = x % 5
P3 = A % 4 // 3
B = A % 4
P4 = B % 3 // 2
PT = P1 * 5 + P2 * 4 + P3 * 3 + P4 * 2
P = P1 + P2 + P3 + P4
if PT != x:
	P = P + 1
	print(P)
else:
	print(P)


n = int(input())
r = 0
r = n // 5
n = n % 5
r = r + n // 4
n = n % 4
r = r + n // 3
n = n % 3
r = r + n // 2
n = n % 2
r = r + n
print(r)


def main():
	from sys import stdin, stdout
	from math import ceil
	stdout.write(str(ceil(int(stdin.readline()) / 5)))
main()


cordinate = int(input())
steps = 0
while cordinate > 0:
	steps = steps + 1
	cordinate = cordinate - 5
print(steps)


crd = int(input())
steps = 0
if crd % 5 == 0:
	steps = crd / 5
else:
	steps = crd // 5 + 1
print(int(steps))


n = int(input())
count = 0
while n != 0:
	count += n // 5
	n %= 5
	count += n // 4
	n %= 4
	count += n // 3
	n %= 3
	count += n // 2
	n %= 2
	count += n
	n = 0
print(count)


friendCord = int(input())
numSteps = 0
currPos = 0
while currPos < friendCord:
	currPos += 5
	numSteps += 1
print(numSteps)


n = int(input())
ans = 0
s = 5
while n > 0:
	if n - s >= 0:
		n = n - s
		ans += 1
	else:
		s = s - 1
print(ans)


n = int(input())
(a, b) = (0, 0)
lst = [5, 4, 3, 2, 1]
for i in range(n):
	if a + 5 <= n:
		a = a + 5
		b = b + 1
		if a == n:
			break
	elif a + 4 <= n:
		a = a + 4
		b = b + 1
		if a == n:
			break
	elif a + 3 <= n:
		a = a + 3
		b = b + 1
		if a == n:
			break
	elif a + 2 <= n:
		a = a + 2
		b = b + 1
		if a == n:
			break
	elif a + 1 <= n:
		a = a + 1
		b = b + 1
		if a == n:
			break
print(b)


distance = int(input())
step = 0
n = 5
while n > 0:
	while True:
		if distance >= n:
			distance -= n
			step += 1
		else:
			break
	n -= 1
print(step)


import sys
import random
import os
x = 0
x = int(input())
if x < 6:
	x = 1
elif x % 5 == 0:
	x = x / 5
else:
	x = x / 5
	x = x + 1
print(int(x))


import math
c = int(input())
a = [1, 2, 3, 4, 5]
if c in a:
	print(1)
else:
	h = math.ceil(c / 1)
	d = math.ceil(c / 2)
	e = math.ceil(c / 3)
	f = math.ceil(c / 4)
	g = math.ceil(c / 5)
	print(min(h, d, e, f, g))


def elephant(n):
	if n <= 5:
		return 1
	if n % 5 == 0:
		return n // 5
	return n // 5 + 1
n = int(input())
print(elephant(n))


entrada = int(input())
base = 0
output = 0
while entrada > base:
	base += 5
	output += 1
print(output)


n = int(input())
numSteps = 0
for i in range(5, 0, -1):
	numSteps += n // i
	n = n % i
print(numSteps)


n = int(input())
move = int(n / 5)
n = n % 5
move = move + int(n / 4)
n = n % 4
move = move + int(n / 3)
n = n % 3
move = move + int(n / 2)
n = n % 2
move = move + int(n)
print(move)


n = int(input())
lis = [5, 4, 3, 2, 1]
num = []
for i in range(5):
	num.append(n // lis[i])
	n = n % lis[i]
print(sum(num))


n = int(input())
step = n // 5 + 1
if n % 5 == 0:
	step -= 1
print(step)


import sys
import math

def solve():
	numbers = [int(x) for x in line.strip().split()]
	if numbers[0] % 5 == 0:
		ans = int(numbers[0] / 5)
	else:
		ans = math.floor(numbers[0] / 5) + 1
	print(ans)
for line in sys.stdin:
	solve()


i = int(input())
moves = 0
if i % 5 == 0:
	moves = i / 5
else:
	moves = i // 5 + 1
print(int(moves))


def elep(n):
	if n <= 5:
		return 1
	elif n % 5 == 0:
		p = n // 5
		return p
	else:
		q = n // 5 + 1
		return q
print(elep(int(input())))


d = int(input())
a = int(d / 5)
add = d - a * 5
if add > 0:
	a = a + 1
print(a)


distance = int(input())
_5 = distance // 5
distance = distance % 5
if distance != 0:
	print(_5 + 1)
else:
	print(_5)


import sys
from os import path
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
	sys.stderr = open('error.txt', 'w')
n = int(input())
print((n + 4) // 5)


n = int(input())
i = 0
while n >= 5:
	n -= 5
	i += 1
if n != 0:
	i += 1
print(i)


d = int(input())
s = 0
count = 0
while 1:
	if d >= 5:
		d -= 5
		count += 1
	elif d >= 4:
		d -= 4
		count += 1
	elif d >= 3:
		d -= 3
		count += 1
	elif d >= 2:
		d -= 2
		count += 1
	elif d == 1:
		d = 0
		count += 1
	else:
		break
print(count)


__author__ = 'artyom'

def main():
	x = read()
	r = x // 5
	if x % 5 > 0:
		r += 1
	return r

def read(mode=2, size=None):
	if mode == 0:
		return input().strip()
	if mode == 1:
		return input().strip().split()
	if mode == 2:
		return int(input().strip())
	if mode == 3:
		return list(map(int, input().strip().split()))
	a = []
	for _ in range(size):
		a.append(read(3))
	return a

def write(s='\n'):
	if s is None:
		s = ''
	if isinstance(s, tuple) or isinstance(s, list):
		s = ' '.join(map(str, s))
	s = str(s)
	print(s, end='\n')
res = main()
write(str(res))


def steps():
	sum = 0
	count = 0
	elephant = [1, 2, 3, 4, 5]
	if n in elephant:
		count = count + 1
		return count
	while True:
		sum = sum + 5
		count = count + 1
		if sum == n:
			return count
			break
		elif sum > n:
			a = sum - n
			sum = sum - a
			if sum == n:
				return count
				break
n = int(input())
print(steps())


n = int(input())
steps = 0
if n >= 5:
	steps += n // 5
	n = n % 5
if n >= 4:
	steps += n // 4
	n = n % 4
if n >= 3:
	steps += n // 3
	n = n % 3
if n >= 2:
	steps += n // 2
	n = n % 2
if n >= 1:
	steps += n // 1
print(steps)


x = int(input())
step = 0
number = [5, 4, 3, 2, 1]
for i in number:
	while x >= i:
		x -= i
		step += 1
print(step)


way = int(input())
step = -(-way // 5)
print(str(step))


n = int(input())
a = 0
while a >= 0 and n > 0:
	if n >= 5:
		a = a + n // 5
		n = n % 5
	elif n >= 4 and n < 5:
		a = a + n // 4
		n = n % 4
	elif n >= 3 and n < 4:
		a = a + n // 3
		n = n % 3
	elif n >= 2 and n < 3:
		a = a + n // 2
		n = n % 2
	elif n >= 1 and n < 2:
		a = a + n // 1
		n = n % 1
print(a)


n = int(input())
count = 0
while n > 5:
	count += 1
	n = n - 5
if n <= 5:
	count += 1
print(count)


a = int(input())
(b, d) = (0, 0)
while a != b:
	if a - b >= 5:
		d += 1
		b += 5
	elif a - b == 4:
		d += 1
		b += 4
	elif a - b == 3:
		d += 1
		b += 3
	elif a - b == 2:
		d += 1
		b += 2
	else:
		d += 1
		b += 1
print(d)


from math import ceil
from math import floor

def mod_expo(n, p, m):
	result = 1
	while p != 0:
		if p % 2 == 1:
			result = result * n % m
		p //= 2
		n = n * n % m
	return result

def find_product(n, m, arr):
	product = 1
	if n <= m:
		for i in range(n):
			for j in range(i + 1, n):
				product = product * abs(arr[i] - arr[j]) % m
		return product
	return 0

def count_tables(l):
	count = 0
	l.sort()
	a = l[1] - l[0]
	b = l[2] - l[0]
	if a % 3 > 0 and a % 3 + (b - (a - a % 3)) >= 3:
		count += 1
	count += l[0] + 2 * a // 3
	return count

def find_shawarma_location(n, ox, oy, px, py):
	mx = 0
	best_x = ox
	best_y = oy
	for i in range(4):
		count = 0
		if i == 0:
			x = max(ox - 1, 0)
			y = oy
		elif i == 1:
			x = ox
			y = max(oy - 1, 0)
		elif i == 2:
			x = min(ox + 1, pow(10, 9))
			y = oy
		else:
			x = ox
			y = min(oy + 1, pow(10, 9))
		for j in range(n):
			if min(px[j], ox) <= x <= max(px[j], ox):
				if min(py[j], oy) <= y <= max(py[j], oy):
					if x == ox and y == oy:
						continue
					else:
						count += 1
		if mx < count:
			mx = count
			best_x = x
			best_y = y
	print(mx)
	print(best_x, best_y)

def find_arr(u, v):
	if u > v or u % 2 != v % 2:
		print(-1)
	elif u == v == 0:
		print(0)
	elif u == v:
		print(1)
		print(u)
	else:
		x = int((v - u) / 2)
		print(x)
		print(u & x)
		if u & x == 0:
			print(2)
			print(u + x, x)
		else:
			print(3)
			print(u, x, x)

def count_steps(n):
	steps = 0
	for i in range(5, 0, -1):
		current = floor(n / i)
		steps += current
		n -= current * i
	return steps
t = 1
while t:
	t = t - 1
	count = 0
	px = []
	py = []
	n = int(input())
	print(count_steps(n))


x = int(input())
n = 5
z = 0
while 1:
	x = x - n
	if x > 0:
		z += 1
	if x < 0:
		x = x + n
		n = n - 1
	if x == 0:
		break
print(z + 1)


location = int(input())
steps_away = location
counter = 0
for i in range(location):
	if steps_away > 0:
		if steps_away - 5 >= 0:
			steps_away -= 5
			counter += 1
		elif steps_away - 4 >= 0:
			steps_away -= 4
			counter += 1
		elif steps_away - 3 >= 0:
			steps_away -= 3
			counter += 1
		elif steps_away - 2 >= 0:
			steps_away -= 2
			counter += 1
		elif steps_away - 1 >= 0:
			steps_away -= 1
			counter += 1
	if steps_away == 0:
		print(counter)
		break


from sys import stdin, stdout
x = int(stdin.readline())
print(x // 5 + int(x % 5 > 0))


x = int(input())
y = 1 + (x - 1) / 5
print(int(y))


import copy
x = int(input())
temp = copy.copy(x)
count = 1
if x <= 5:
	print('1')
else:
	while x > 5:
		x = x - 5
		count += 1
	print(count)


dist = int(input())
l = [5, 4, 3, 2, 1]
i = 0
for el in l:
	if dist == 0:
		break
	i += dist // el
	dist = dist % el
print(i)


x = int(input())
step = 0
if x <= 5 and x >= 0:
	print('1')
elif x % 5 == 0:
	x = x // 5
	print(x)
else:
	x = x // 5
	x += 1
	print(x)


n = int(input())
if n <= 5:
	print(1)
else:
	ans = n // 5
	x = n % 5
	if x == 0:
		print(ans)
	else:
		print(ans + 1)
	pass


distance = int(input())
res = distance // 5 + 1 if distance % 5 != 0 else distance // 5
print(res)


friend = int(input())
steps = [5, 4, 3, 2, 1]
bigger = 0
n = 0
while friend > 0:
	if friend - steps[bigger] >= 0:
		friend -= steps[bigger]
		n += 1
	else:
		bigger += 1
print(n)


a = int(input())
if a % 5 != 0:
	g = a // 5
	if a <= 5:
		print('1')
	else:
		print(g + 1)
else:
	print(int(a // 5))


a = int(input())
pasos = 0
if a % 5 == 0:
	print(a // 5)
elif a % 5 != 0:
	print(a // 5 + 1)


a = int(input())
sum = a // 5 + a % 5 // 4
b = a % 5
b = b % 4
sum = sum + b // 3 + b % 3 // 2
d = b % 3
d = d % 2
sum = sum + d
print(sum)


def ceiling(a):
	if a > int(a):
		return int(a + 1)
	return int(a)
n = int(input())
print(ceiling(n / 5))


number = int(input())
step = number // 5
if number % 5 == 0:
	print(step)
else:
	print(step + 1)


x = int(input())
steps = [5, 4, 3, 2, 1]
moves = 0
if x < 5:
	print(1)
else:
	moves = x // 5
	if x % 5 in steps:
		moves += 1
	print(moves)


x = int(input())
ans = 0
for i in range(5):
	ans += x // (5 - i)
	x = x % (5 - i)
print(ans)


q = int(input())
g = q // 5
if q % 5 != 0:
	g = g + 1
print(g)


x = int(input())
k = 0
positions = [1, 2, 3, 4, 5]
if x in positions:
	print(1)
else:
	k = x / 5
	if int(k % 1 * 10) == 0:
		print(int(k))
	else:
		print(int(k + 1))


import sys, os.path
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
sys.setrecursionlimit(10 ** 5)

def ii():
	return int(sys.stdin.readline())

def mi():
	return map(int, sys.stdin.readline().split())

def li():
	return list(map(int, sys.stdin.readline().split()))

def solve():
	n = ii()
	print(n // 5 + bool(n % 5))
solve()


n = int(input())
max5 = n // 5
n = n % 5
max4 = n // 4
n = n % 4
max3 = n // 3
n = n % 3
max2 = n // 2
n = n % 2
max1 = n // 1
max = max5 + max1 + max2 + max3 + max4
print(max)


distance = int(input())
five_steps = distance // 5
left = distance % 5
if left == 0:
	print(five_steps)
else:
	print(five_steps + 1)


from math import ceil
import math
integer = int(input())
answer = math.inf
for i in [1, 2, 3, 4, 5]:
	result = ceil(integer / i)
	if result < answer:
		answer = result
print(answer)


x = int(input())
n = 0
while x != 0:
	for m in [5, 4, 3, 2, 1]:
		if x >= m:
			n = n + x // m
			x = x - m * (x // m)
			break
print(n)


x = int(input())
m = []
import math
for i in range(1, 6):
	m.append(math.ceil(x / i))
print(min(m))


def fun():
	a = int(input())
	if a % 5 == 0:
		print(a // 5)
	else:
		print(a // 5 + 1)
fun()


x = int(input())
import math as m
print(m.ceil(x / 5))


import sys
n = 0
for l in sys.stdin:
	if n == 0:
		k = int(l)
		n = n + 1
		break
g = 0
number = 0
while g == 0:
	if k == 0:
		break
	if k / 5 < 1:
		if k / 4 < 1:
			if k / 3 < 1:
				if k / 2 < 1:
					k = k - 1
					number = number + 1
					break
				else:
					k = k - 2
					number = number + 1
			else:
				k = k - 3
				number = number + 1
		else:
			k = k - 4
			number = number + 1
	else:
		k = k - 5
		number = number + 1
print(number)


xds = int(input())
csd = xds // 5
xds = xds % 5
csd = csd + xds // 4
xds = xds % 4
csd = csd + xds // 3
xds = xds % 3
csd = csd + xds // 2
xds = xds % 2
csd = csd + xds
print(csd)


n = int(input())
if n < 5:
	print(1)
	quit()
steps = n // 5
if not n % 5 == 0:
	steps += 1
print(steps)


def get():
	res = [int(x) for x in input().split()]
	return res[0] if len(res) == 1 else res
x = get()
print((x + 4) // 5)


x = int(input())
step = 0
tgo = x
if x < 6:
	step = 1
else:
	for i in range(x):
		if tgo > 5:
			tgo -= 5
			step += 1
		elif 0 < tgo <= 5:
			tgo = 0
			step += 1
		else:
			break
print(step)


i = int(input())
sum = 0
while i > 0:
	i -= 5
	sum += 1
print(sum)


x = 0
z = int(input())
while z > 5:
	z = z - 5
	x += 1
print(x + 1)


n = int(input())
a = n // 5
if n % 5 > 0:
	a += 1
else:
	pass
print(a)


x = int(input())
y = [1, 2, 3, 4, 5]
min = 99999999
for i in range(len(y)):
	if x % y[i] == 0:
		if int(x / y[i]) < min:
			min = int(x / y[i])
	elif int(x / y[i]) < min:
		min = int(x / y[i]) + 1
print(min)


x = int(input())
count = 0
for i in reversed(range(6)):
	if i == 0:
		pass
	else:
		count += int(x / i)
		x = int(x % i)
print(int(count))


n = int(input())
x = n // 5
r = n % 5
if r == 0:
	print(x)
if r != 0:
	print(x + 1)


x = int(input())
numberOfSteps = x // 5
x = x % 5
if x != 0:
	numberOfSteps += 1
print(numberOfSteps)


s = int(input())
count = 0
l = [5, 4, 3, 2, 1]
for i in l:
	b = s // i
	if b != 0:
		count = count + b
		s = s % i
	else:
		continue
print(count)


a = int(input())
print(abs(-a // 5))


x = int(input())
a = [1, 2, 3, 4, 5]
step = 0
while x > 0:
	x -= max(a)
	step += 1
print(step)


user = int(input())
c = user % 5
a = user // 5
if c != 0:
	print(a + 1)
else:
	print(a)


num = int(input())
s = num // 5
num = num % 5
m = num // 4
num = num % 4
o = num // 3
num = num % 3
p = num // 2
num = num % 2
q = num // 1
num = num % 1
print(s + p + q + m + o)


num = int(input())
if num % 5 == 0:
	p = num // 5
	print(p)
elif num % 5 != 0:
	p = num / 5
	print(int(p) + 1)


(a, t, i) = (int(input()), 0, 5)
while i >= 2:
	t = t + a // i
	a = a % i
	i = i - 1
t = t + a
print(t)


def solve(n):
	candidates = [5, 4, 3, 2, 1]
	count = 0
	while n > 0:
		for candidate in candidates:
			if n // candidate > 0:
				count += n // candidate
				n = n % candidate
				break
	return count

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


dist = int(input())
step_distances = [5, 4, 3, 2, 1]
num_steps = 0
for s_d in step_distances:
	num_steps += dist // s_d
	dist = dist % s_d
print(num_steps)


def ele(k):
	if k >= 5:
		n = int(k / 5)
		k = k - n * 5
		if k == 0:
			return n
		else:
			return n + ele(k)
	elif k == 4 or k == 3 or k == 2 or (k == 1):
		return 1
n = int(input())
print(ele(n))


entfernung = int(input())
schritt = 0
while entfernung > 0:
	schritt += 1
	entfernung -= 5
print(schritt)


steps = [5, 4, 3, 2, 1]

def main():
	coord = int(input())
	k = 0
	for i in steps:
		y = coord // i
		k += y
		coord = coord - i * y
		i += 1
	print(k)
main()


n = int(input())
all = 0
all += n // 5
n %= 5
all += n // 4
n %= 4
all += n // 3
n %= 3
all += n // 2
n %= 2
all += n // 1
print(all)


s = int(input())
count = 0
count += s // 5
s -= s // 5 * 5
count += s // 4
s -= s // 4 * 4
count += s // 3
s -= s // 3 * 3
count += s // 2
s -= s // 2 * 2
count += s
print(count)


n = int(input())
r = n % 5
if r > 0:
	r = 1
q = n // 5
print(q + r)


def elephant(num):
	count = 0
	while num != 0:
		if num - 5 >= 0:
			num -= 5
		elif num - 4 >= 0:
			num -= 4
		elif num - 3 >= 0:
			num -= 3
		elif num - 2 >= 0:
			num -= 2
		else:
			num -= 1
		count += 1
	print(count)
elephant(int(input()))


dist = int(input())
steps = 0
for i in reversed(range(1, 6)):
	while dist - i >= 0:
		dist -= i
		steps += 1
print(steps)


n = int(input())
steps_len = [1, 2, 3, 4, 5]
num_steps = 0
for i in steps_len[::-1]:
	if n >= i:
		num_steps += n // i
		n -= num_steps * i
print(num_steps)


def roundoff(x, n):
	remainder = x % n
	roundoff_remainder = int((remainder + n / 2) // n)
	return x // n + roundoff_remainder

def abs(n):
	if n < 0:
		n = -n
	return n
x = int(input())
if x > 5:
	if x % 5:
		print(x // 5 + 1)
	else:
		print(x // 5)
else:
	print(1)


k = int(input())
print(k // 5 + k % 5 // 4 + k % 5 % 4 // 3 + k % 5 % 4 % 3 // 2 + k % 5 % 4 % 3 % 2 // 1)


max_steps = 5
address = 0
steps = 0
n = int(input())
while address != n:
	if max_steps > n - address:
		max_steps -= 1
	else:
		address += max_steps
		steps += 1
print(steps)


def read(s=''):
	return [int(e) for e in input(s).split()]
x = read()[0]
counter = 0
while x > 0:
	if x > 4:
		x = x - 5
	elif x > 3:
		x = x - 4
	elif x > 2:
		x = x - 3
	elif x > 1:
		x = x - 2
	elif x > 0:
		x = x - 1
	counter = counter + 1
print(counter)


coordinates = int(input())
number = 0
if coordinates % 5 > 0:
	print(coordinates // 5 + 1)
else:
	print(coordinates // 5)


def getInts():
	return [int(s) for s in input().split()]

def getInt():
	return int(input())

def getStrs():
	return [s for s in input().split()]

def getStr():
	return input()

def listStr():
	return list(input())

def solve():
	X = getInt()
	return (X % 5 > 0) + X // 5
ans = solve()
print(ans)


n = int(input())
a = n // 5
b = n % 5
t = 0
q = 0
if b > 5:
	t = b // 5
	q = b % 5
elif b > 0 and b < 5:
	b = 1
print(a + b + t + q)


x = int(input())
output = 0
while x > 0:
	if x > 5:
		output += 1
		x = x - 5
	else:
		output += 1
		x = 0
print(output)


from math import ceil as c
n = int(input())
k = c(n / 5)
print(k)


x = int(input())
jump = 0
a = x // 5
x = x - a * 5
jump += a
a = x // 4
x = x - a * 4
jump += a
a = x // 3
x = x - a * 3
jump += a
a = x // 2
x = x - a * 2
jump += a
jump += x
print(jump)


x = int(input())
x1 = 0
i = 0
while x1 < x:
	x1 += 5
	i += 1
print(i)


def _617A(distance):
	return distance // 5 + (1 if distance % 5 != 0 else 0)
print(_617A(int(input())))


X = int(input())
print((X + 4) // 5)


ans = 0
x = input()
y = int(x)
i = 5
while i >= 1:
	if y / i > 0:
		ans = ans + int(y / i)
		p = int(y / i) * i
		y = y - p
	i = i - 1
print(ans)


dis = int(input())
ls = [1, 2, 3, 4, 5]
count = 0
if dis in ls:
	print(1)
else:
	while dis > 5:
		dis = dis - 5
		count += 1
	print(count + 1)


n = int(input())
hasil = 0
while n > 4:
	hasil += 1
	n -= 5
if n >= 1 and n <= 4:
	hasil += 1
print(hasil)


n = int(input())
if n % 5 == 0:
	print(n // 5)
if n < 5:
	print(1)
if n % 5 != 0 and n > 4:
	print(n // 5 + 1)


n = int(input())
r = 0
i = 0
d = [5, 4, 3, 2, 1]
while n > 0:
	if n >= d[i]:
		r += 1
		n -= d[i]
	else:
		i += 1
print(r)


e = [1, 2, 3, 4, 5]
d = int(input())
c = 0
while d != 0 and len(e) > 0:
	td = 0
	mx = max(e)
	if mx <= d:
		td = d // mx
		d -= mx * td
		c += td
	e.remove(mx)
print(c)


import math
n = int(input())
if n <= 5:
	print('1')
else:
	res = 1
	while n > 5:
		res += 1
		n -= 5
	print(res)


x = int(input())
numCount = 0
numCount += x // 5
x = x % 5
numCount += x // 4
x = x % 4
numCount += x // 3
x = x % 3
numCount += x // 2
x = x % 2
numCount += x
print(numCount)


k = int(input())
kil = k // 5
ost = k % 5
kil = kil + ost // 4
ost = ost % 4
kil = kil + ost // 3
ost = ost % 3
kil = kil + ost // 2
ost = ost % 2
kil = kil + ost // 1
ost = ost % 1
print(kil)


import math
import sys
import re
n = int(input())
c = 0
if n % 5 == 0:
	c = int(n // 5)
else:
	c = int(n // 5) + 1
print(c)


n = int(input())
ss = {1, 2, 3, 4, 5}
s = 1
if n in ss:
	print(s)
elif n > 5:
	s = int(n / 5)
	t = n % 5
	if t == 0:
		print(s)
	else:
		print(s + 1)


x = int(input())
l = [5, 4, 3, 2, 1]
z = 0
for i in range(0, len(l)):
	z += x // l[i]
	x = x % l[i]
print(z)


N = int(input())
x = 0
x += N // 5
N = N % 5
x += N // 4
N = N % 4
x += N // 3
N = N % 3
x += N // 2
N = N % 2
x += N // 1
N = N % 1
print(x)


t = int(input())
res = 0
i = 5
while t > 0 and i != 0:
	if t >= i:
		res += (t - t % i) / i
		t -= t - t % i
	i -= 1
print(int(res))


n = int(input().strip())
print(n // 5 + (1 if n % 5 else 0))


Coordinate = int(input(''))
answer = int(Coordinate / 5)
if Coordinate <= 5:
	remainder = 0
	total = 1
	print(total)
elif Coordinate % 5 == 0:
	remainder = 0
else:
	remainder = 1
total = answer + remainder
if Coordinate > 5:
	print(total)


x = int(input())
count = 0
list1 = [5, 4, 3, 2, 1]
for y in list1:
	if y <= x:
		n = x / y
		count += n
		x = x % y
print(int(count))


n = int(input())

def solution(x):
	a_1 = x // 5
	a_2 = (x - a_1 * 5) // 4
	a_3 = (x - a_1 * 5 - a_2 * 4) // 3
	a_4 = (x - a_1 * 5 - a_2 * 4 - a_3 * 3) // 2
	a_5 = x - a_1 * 5 - a_2 * 4 - a_3 * 3 - a_4 * 2
	return a_1 + a_2 + a_3 + a_4 + a_5
print(solution(n))


import sys
n = int(input().strip())
c = 0
r = 0
if n % 5 == 0:
	c = int(n / 5)
	print(c)
	sys.exit()
else:
	c = int(n // 5)
	r = n % 5
	n = r
if n % 4 == 0:
	c += int(n / 4)
	print(c)
	sys.exit()
else:
	c += int(n // 4)
	r = n % 4
	n = r
if n % 3 == 0:
	c += int(n / 3)
	print(c)
	sys.exit()
else:
	c += int(n // 3)
	r = n % 3
	n = r
if n % 2 == 0:
	c += int(n / 2)
	print(c)
	sys.exit()
else:
	c += int(n // 2)
	r = n % 2
print(c + r)


a = int(input())
s = 0
if a <= 5:
	print(1)
if a > 5:
	while a > 5:
		a = a - 5
		s = s + 1
	print(s + 1)


x = int(input())
step = x // 5
rem = x % 5
step = step + rem // 4
rem = rem % 4
step = step + rem // 3
rem = rem % 3
step = step + rem // 2
rem = rem % 2
print(step + rem)


pozostala_liczba_krokow_do_przejscia = int(input())
liczba_krokow = 0
for dlugosc_skoku in [5, 4, 3, 2, 1]:
	ile_razy_moge_wykonac_skok_podanej_dlg = pozostala_liczba_krokow_do_przejscia // dlugosc_skoku
	liczba_krokow += ile_razy_moge_wykonac_skok_podanej_dlg
	ile_krokow_poszedlem = ile_razy_moge_wykonac_skok_podanej_dlg * dlugosc_skoku
	pozostala_liczba_krokow_do_przejscia -= ile_krokow_poszedlem
print(liczba_krokow)


def helpElephant(x):
	min_steps = x // 5
	min_steps += 1 if x % 5 > 0 else 0
	return min_steps

def main():
	x = int(input())
	print(helpElephant(x))
main()


x = int(input())
c = x // 5
x %= 5
c += x // 4
x %= 4
c += x // 3
x %= 3
c += x // 2
x %= 2
c += x // 1
x %= 1
print(c)


def move(x):
	count = 0
	for i in range(5, 0, -1):
		count += int(x / i) if x >= i else 0
		x = x % i if x >= i else x
		if x < 1:
			break
	return count
print(move(int(input())))


distance = int(input())
rem = 0 if not distance % 5 else 1
quo = distance // 5
print(rem + quo)


no = int(input())
count = 0
while no != 0:
	if no < 0:
		break
	if no >= 5:
		no = no - 5
		count += 1
	elif no >= 4 and no < 5:
		no = no - 4
		count += 1
	elif no >= 3 and no < 4:
		no = no - 3
		count += 1
	elif no >= 2 and no < 3:
		no = no - 2
		count += 1
	else:
		no = no - 1
		count += 1
print(count)


n = int(input())
count = 0
if n < 6:
	print('1')
else:
	divide = n // 5
	modulo = n % 5
	if modulo == 0:
		print(divide)
	else:
		print(divide + 1)


n = int(input())
step = 0
for i in range(5, 0, -1):
	step = step + int(n / i)
	n = n % i
print(step)


n = int(input())
c = 0
j = 5
while n != 0:
	c = c + n // j
	n = n % j
	j = j - 1
print(c)


x = int(input())
if x % 5 == 0:
	steps = x // 5
elif x % 5 != 0:
	steps = x // 5 + 1
print(steps)


def pasos(x):
	steps = 0
	i = 5
	while i > 0:
		steps += int(x) // i
		x = x % i
		i -= 1
	print(steps)
x = int(input())
pasos(x)


import sys
n = int(input())
if n % 5 == 0:
	print(int(n / 5))
else:
	print(int(n / 5 + 1))


s = int(input())
if s % 5 == 0:
	print(s // 5)
elif s % 5 != 0:
	print(s // 5 + 1)


import math
n = input()
n = int(n)
i = 5
c = 0
while i > 0:
	a = n / i
	c = c + math.floor(a)
	b = n % i
	if b == 0:
		break
	else:
		n = b
	i = i - 1
print(int(c))


n = int(input())
step = 0
if n % 5 >= 0:
	step += int(n / 5)
	n = n % 5
	if n % 4 >= 0:
		step += int(n / 4)
		n = n % 4
		if n % 3 >= 0:
			step += int(n / 3)
			n = n % 3
			if n % 2 >= 0:
				step += int(n / 2)
				n = n % 2
				if n % 1 >= 0:
					step += int(n / 1)
print(step)


a = int(input())
c = 0
while a != 0:
	if a == 5 or a == 4 or a == 3 or (a == 2) or (a == 1):
		c += 1
		a = 0
	if a > 5:
		c += 1
		a = a - 5
print(c)


i = 5
j = 0
a = int(input())
while i != 0:
	while a - i >= 0:
		j += 1
		a -= i
	i -= 1
print(j)


a = int(input())
if a <= 5:
	print('1')
else:
	print(a // 5 + a % 5 // 4 + a % 5 % 4 // 3 + a % 5 % 4 % 3 // 2 + a % 5 % 4 % 3 % 2 // 1)


x = int(input())
count = 0
for i in range(5, 0, -1):
	y = x // i
	count += y
	x -= i * y
print(count)


a = int(input())
ans = 0
ans += a // 5
a %= 5
ans += a // 4
a %= 4
ans += a // 3
a %= 3
ans += a // 2
a %= 2
ans += a
print(int(ans))


i = int(input())
l = 0
while True:
	if i >= 5:
		l += 1
		i -= 5
	elif i >= 4:
		l += 1
		i -= 4
	elif i >= 3:
		l += 1
		i -= 3
	elif i >= 2:
		l += 1
		i -= 2
	elif i >= 1:
		l += 1
		i -= 1
	if i == 0:
		break
print(int(l))


fhouse = int(input())
count = 0
i = 5
distance = 0
while distance < fhouse:
	distance += i
	count += 1
print(count)


import math
n = int(input())
z = math.ceil(n / 5)
print(z)


x = int(input())
s = 0
L = [5, 4, 3, 2, 1]
for i in L:
	s = s + x // i
	x = x % i
print(s)


from collections import deque
import math
n = int(input())
print(n // 5 + (1 if n % 5 != 0 else 0))


d = int(input())
i = 5
res = 0
while d > 0:
	res = res + d // i
	d = d % i
	i -= 1
print(res)


import sys

def main():
	total = int(sys.stdin.readline().strip())
	steps = total // 5
	if total % 5 != 0:
		steps += 1
	print(steps)
main()


number = int(input())
if number < 5:
	print(1)
else:
	count = int(number / 5)
	if number % 5 == 0:
		print(count)
	else:
		print(count + 1)


a = int(input().strip())
c = a // 5
if a % 5 > 0:
	c += 1
print(c)


x = int(input())
(ans, a) = (0, 5)
while a > 0:
	b = x // a
	x %= a
	ans += b
	a -= 1
print(int(ans))


def elephant(number):
	if number % 5 == 0:
		return number // 5
	else:
		return number // 5 + 1
number = int(input())
print(elephant(number))


import math
friends_x = int(input())
print(math.ceil(friends_x / 5))


n = int(input())
k = 0
if n <= 5:
	print(1)
else:
	while not n == 0:
		if n - 5 >= 0:
			n = n - 5
			k += 1
		if n - 4 == 0:
			n = n - 4
			k += 1
		if n - 3 == 0:
			n = n - 3
			k += 1
		if n - 2 == 0:
			n = n - 2
			k += 1
		if n - 1 == 0:
			n = n - 1
			k += 1
	print(k)


t = int(input())
print(t // 5 + (t % 5 != 0))


friend = int(input())
steps = friend // 5
position = friend // 5 * 5
if position == friend:
	print(steps)
else:
	print(steps + 1)


def solution(n):
	count = 0
	if n == 0:
		return 0
	if 1 <= n <= 5:
		count += 1
	else:
		while n > 5:
			count += 1
			n -= 5
		if 1 <= n <= 5:
			count += 1
	return count
print(solution(int(input())))


import sys
x = int(sys.stdin.readline())
step = 5
count_steps = 0
while step > 0 and x > 0:
	count_steps += x // step
	x = x % step
	step -= 1
print(count_steps)


a = int(input())
c = int(a / 5)
d = a % 5
if c > 0 and d > 0:
	print(c + 1)
if c > 0 and d == 0:
	print(c)
if c == 0:
	print(1)


a = int(input())
a5 = a // 5
rest = a % 5
a4 = rest // 4
rest = rest % 4
a3 = rest // 3
rest = rest % 3
a2 = rest // 2
rest = rest % 2
a1 = rest // 1
rest = rest % 1
step = a5 + a4 + a3 + a2 + a1
print(step)


i = 5
x = int(input())
count = 0
while True:
	if x >= i:
		x -= i
		count += 1
	else:
		i -= 1
	if x <= 0:
		break
print(count)


x = int(input())
moves = [1, 2, 3, 4, 5]
t = 0
high = -1
while x != 0:
	step = moves[high]
	while step <= x:
		t += x // step
		x %= step
	high -= 1
print(t)


import sys, os.path
import math
if os.path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
n = int(input())
if n % 5 == 0:
	print(n // 5)
else:
	print(n // 5 + 1)


dist = int(input())
travels = [5, 4, 3, 2, 1]
count = 0
for travel in travels:
	while dist > 0:
		dist -= travel
		count += 1
print(count)


s = int(input())
l = [5, 4, 3, 2, 1]
count = 0
i = 0
while i < 5:
	if s // l[i] != 0:
		count += s // l[i]
		s = s % l[i]
	i += 1
print(count)


n = int(input())
a = n // 5
d = n % 5
a += d // 4
d = d % 4
a += d // 3
d = d % 3
a += d // 2
d = d % 2
a += d // 1
print(a)


x = input()
x = int(x)
rs = 0
while x > 0:
	for i in range(6):
		if x >= 5 - i:
			x -= 5 - i
			rs += 1
			break
print(rs)


n = int(input())
j = 5
ans = 0
while --n:
	while n >= j:
		n -= j
		ans += 1
	j -= 1
print(ans)


from sys import stdin
x = int(stdin.readline())
if x <= 5:
	print(1)
else:
	d = x // 5
	if x % 5 != 0:
		d += 1
	print(d)


n = int(input())
resto = n % 5
if resto == 0:
	print(n // 5)
else:
	print(n // 5 + 1)


n = int(input())
l = [1, 2, 3, 4, 5]
c = 1
if n in l:
	print(c)
else:
	while n > 5:
		n = n - 5
		c += 1
	print(c)


num = int(input())
steps = 0
if num < 6:
	print('1')
else:
	for i in range(5):
		while num - i > 0:
			num -= 5
			steps += 1
	print(steps)


def main():
	number = input().strip()
	number = int(number)
	counter = 0
	if number >= 10:
		rest_number = number % 5
		number_temp = number // 5
		counter = number_temp
	if number < 10:
		rest_number = number
	while rest_number != 0:
		if rest_number >= 5:
			rest_number -= 5
		elif rest_number >= 4:
			rest_number -= 4
		elif rest_number == 3:
			rest_number -= 3
		elif rest_number == 2:
			rest_number -= 2
		elif rest_number == 1:
			rest_number -= 1
		counter += 1
	print(counter)
main()


import math
distance = int(input())
numSteps = distance / 5
if distance % 5 > 0:
	numSteps = math.floor(numSteps) + 1
print(int(numSteps))


def solution():
	coordinate = int(input())
	(q, r) = divmod(coordinate, 5)
	print(str(q + 1) if r > 0 else str(q))
solution()


x = int(input())
cik = x // 5
if x % 5 != 0:
	cik += 1
print(cik)


get = int(input())
ans = 0
ans = (get + 4) // 5
print(ans)


num = int(input())
count = 0
for i in range(1, 6)[::-1]:
	temp = num // i
	num = num - i * temp
	count += temp
	if num == 0:
		break
print(count)


r = int(input())
(q, d) = (0, 5)
while r >= d:
	q += 1
	r -= d
print(str(q + (0 if r == 0 else 1)))


house = int(input())
at = 0
cont = 0
while at < house:
	at += 5
	cont += 1
print(cont)


f = int(input())
mi = 0
while f >= 0:
	if f >= 5:
		mi += 1
		f -= 5
	elif f >= 4:
		mi += 1
		f -= 4
	elif f >= 3:
		mi += 1
		f -= 3
	elif f >= 2:
		mi += 1
		f -= 2
	else:
		mi += 1
		f -= 1
print(mi - 1)


len = int(input())
step = 0
if len >= 5:
	step += int(len / 5)
	len = len % 5
if len >= 4:
	step += int(len / 4)
	len = len % 4
if len >= 3:
	step += int(len / 3)
	len = len % 3
if len >= 2:
	step += int(len / 2)
	len = len % 2
step += len
print(step)


from sys import stdin
x = stdin.readline().rstrip()
x = int(x)
leftover = x
steps = 0
for move_pos in range(5, 0, -1):
	if leftover >= move_pos:
		steps += leftover // move_pos
		leftover %= move_pos
print(steps)


x = int(input())
if x == 1 or x == 2 or x == 3 or (x == 4) or (x == 5):
	print(1)
else:
	a = x // 5
	b = x % 5
	c = b % 4
	d = c % 3
	e = d % 2
	n = a + b // 4 + c // 3 + d // 2 + e // 1
	print(n)


n = int(input())
s = 0
c = 0
while n > s:
	s += 5
	c += 1
print(c)


m = int(input())
c = 0
if m >= 5:
	while m >= 5:
		m -= 5
		c += 1
if m >= 4:
	while m >= 4:
		m -= 4
		c += 1
if m >= 3:
	while m >= 3:
		m -= 3
		c += 1
if m >= 2:
	while m >= 2:
		m -= 2
		c += 1
if m >= 1:
	while m >= 1:
		m -= 1
		c += 1
print(c)


friend = int(input())
movement = (5, 4, 3, 2, 1)
count = 0
time = []
while friend > 0:
	for i in movement:
		if friend >= i:
			count += 1
			friend -= i
			break
print(count)


x = int(input())
allowed_pos = [5, 4, 3, 2, 1, 0]
if x in allowed_pos:
	print(1)
else:
	i = 0
	count = 0
	while x > 0:
		if x >= allowed_pos[i]:
			x -= allowed_pos[i]
			count += 1
		else:
			i += 1
			x -= allowed_pos[i]
			count += 1
	print(count)


steps = 0
dest = int(input())
if dest >= 5:
	steps += dest // 5
	dest %= 5
if dest >= 4:
	steps += dest // 4
	dest %= 4
if dest >= 3:
	steps += dest // 3
	dest %= 3
if dest >= 2:
	steps += dest // 2
	dest %= 2
steps += dest
print(steps)


number = int(input())
answer = int((number - 1) // 5 + 1)
print(answer)


x = int(input())
sum = 0
sum = sum + x // 5
x = x - x // 5 * 5
sum = sum + x // 4
x = x - x // 4 * 4
sum = sum + x // 3
x = x - x // 3 * 3
sum = sum + x // 2
x = x - x // 2 * 2
sum = sum + x
print(int(sum))


distance = int(input())
step = 0
while distance > 0:
	distance = distance - 5
	step = step + 1
print(step)


a = int(input())
c = 0
ri = a
for i in range(5, 0, -1):
	while ri - i < ri and ri - i >= 0:
		ri -= i
		c += 1
print(c)


x = input()

def how_many(value):
	counter = 0
	div = 5
	while value > 0:
		y = value // div
		counter += y
		if y > 0:
			value -= counter * div
		div -= 1
	return counter
print(how_many(int(x)))


x = int(input())
if x % 5 == 0 and x >= 1:
	y = x / 5
	y = int(y)
	print(y)
elif x % 5 == 1 and x >= 1:
	y = (x - 1) / 5 + 1
	y = int(y)
	print(y)
elif x % 5 == 2 and x >= 1:
	y = (x - 2) / 5 + 1
	y = int(y)
	print(y)
elif x % 5 == 3 and x >= 1:
	y = (x - 3) / 5 + 1
	y = int(y)
	print(y)
elif x % 5 == 4 and x >= 1:
	y = (x - 4) / 5 + 1
	y = int(y)
	print(y)


from math import ceil
x = int(input())
z = ceil(x / 5)
print(z)


import math as m
q = int(input())
if q < 6:
	print(1)
else:
	print(m.ceil(q / 5))


n = int(input())
den = 0
while True:
	if n - 5 >= 0:
		den += 1
		n -= 5
	elif n - 4 >= 0:
		den += 1
		n -= 4
	elif n - 3 >= 0:
		den += 1
		n -= 3
	elif n - 2 >= 0:
		den += 1
		n -= 2
	elif n - 1 >= 0:
		den += 1
		n -= 1
	if n == 0:
		break
print(den)


x = int(input())
count = 0
for i in range(5, 0, -1):
	if x != 0:
		aux = x
		while aux % i != 0:
			aux -= 1
		count += aux // i
		x -= aux
print(count)


n = int(input())
s = n
k = 0
while s != 0:
	if s >= 5:
		w = s - 5
		s = w
		k = k + 1
	elif s >= 4:
		w = s - 4
		s = w
		k = k + 1
	elif s >= 3:
		w = s - 3
		s = w
		k = k + 1
	elif s >= 2:
		w = s - 2
		s = w
		k = k + 1
	else:
		w = s - 1
		w = s - 1
		s = w
		k = k + 1
print(k)


n = int(input())
if n % 5 == 0:
	rs = n // 5
else:
	rs = n // 5 + 1
print(rs)


val = int(input())
count = 0
while val > 5:
	val = val - 5
	count += 1
count += 1
print(count)


coordinateLocation = int(input())
stepTaken = coordinateLocation // 5 + 1
if coordinateLocation % 5 == 0:
	stepTaken = coordinateLocation // 5
print(stepTaken)


n = int(input())
k = n // 5
k1 = n % 5
if k1 == 0:
	print(k)
else:
	print(k + 1)


def check():
	n = int(input())
	su = n // 5
	if n % 5 != 0:
		su += 1
	return su
print(check())


def main():
	pos = int(input())
	if pos % 5 == 0:
		result = int(pos / 5)
	else:
		result = int(pos / 5) + 1
	print(int(result))
main()


x = int(input())
count = 0
z = x // 5
if x % 5 == 0:
	print(z)
else:
	print(z + 1)


def min_steps(coordinate):
	steps = 0
	elephant_steps = [1, 2, 3, 4, 5]
	while coordinate > 0:
		if coordinate in elephant_steps:
			steps += 1
			coordinate = 0
		else:
			steps += coordinate // 5
			coordinate = coordinate % 5
	return steps
coordinate = int(input())
print(min_steps(coordinate))


cd = int(input())
if cd <= 5:
	print(1)
else:
	steps = 0
	while cd != 0:
		steps += 1
		if cd >= 5:
			cd -= 5
		else:
			break
	print(steps)


import math
n = int(input())
print(math.ceil(n / 5))
for i in 'island':
	if i == 'is':
		print('HEY HO MATEY')
	else:
		pass


def elephant():
	i = int(input())
	s = 0
	if i % 5 == 0:
		s = int(i / 5)
		print(int(s))
		return
	s = int(i / 5)
	i = i % 5
	if i % 4 == 0:
		s += int(i / 4)
		print(int(s))
		return
	s += int(i / 4)
	i = i % 4
	if i % 3 == 0:
		s += int(i / 3)
		print(int(s))
		return
	s += int(i / 3)
	i = i % 3
	if i % 2 == 0:
		s += int(i / 2)
		print(int(s))
		return
	s += int(i / 2)
	i = i % 2
	if i % 1 == 0:
		s += int(i / 1)
		print(int(s))
		return
elephant()


print(int(-(-float(input()) // 5)))


(s, r) = divmod(int(input()), 5)
print(s + (1 if r else 0))


import sys
from math import *

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
print((mint() + 4) // 5)


n = int(input())
ans = n // 5
if n % 5 >= 1 and n % 5 <= 4:
	ans += 1
print(ans)


steps = [5, 4, 3, 2, 1]
need = int(input())
ans = 0
for i in steps:
	if need == 0:
		break
	more = need % i
	ans += int(need / i)
	need = more
print(ans)


def short_dis(n):
	tot = 0
	if n == 0:
		return 0
	if n <= 5 and n != 0:
		return 1
	else:
		while True:
			if n <= 0:
				break
			n = n - 5
			tot = tot + 1
	return tot
i = int(input())
print(short_dis(i))


a = int(input())
s5 = a // 5
s51 = a % 5
s4 = s51 // 4
s41 = s51 % 4
s3 = s41 // 3
s31 = s41 % 3
s2 = s31 // 2
s21 = s31 % 2
c = s5 + s4 + s3 + s2 + s21
print(c)


print(int(int(input()) / 5 + 0.85))


x = int(input())
counter = 0
counter += int(x / 5)
x = x % 5
counter += int(x / 4)
x = x % 4
counter += int(x / 3)
x = x % 3
counter += int(x / 2)
x = x % 2
counter += int(x / 1)
print(counter)


def main_test():
	s = input().split(' ')
	if int(s[0]) + int(s[1]) + int(s[2]) >= 2:
		tt += 1
T = int(input())
l = T // 5
if T % 5 != 0:
	l += 1
print(l)


r = int(input())
if r <= 5:
	print(1)
elif r % 5 == 0:
	print(int(r / 5))
else:
	pasos = int(r / 5)
	print(pasos + 1)


x = int(input())
k = 0
for i in range(5, 0, -1):
	k += x // i
	x %= i
print(k)


x = int(input())
s1 = x / 5
rem = x % 5
s1 = int(s1)
s2 = rem / 4
rem1 = rem % 4
s2 = int(s2)
s3 = rem1 / 3
rem2 = rem1 % 3
s3 = int(s3)
s4 = rem2 / 2
s4 = int(s4)
s5 = rem2 % 2
s = s1 + s2 + s3 + s4 + s5
s = int(s)
print(s)


x = input()
y = int(x)
n = int(y / 5)
if y % 5 > 0:
	n = n + 1
print(n)


nn = int(input())
temp = nn + 4
print(temp // 5)


n = int(input())
if n % 5 == 0:
	print(round(n / 5))
else:
	print(round(n // 5 + 1))


x = int(input())
i = 0
if x % 5 == 0:
	i = x / 5
if x % 5 == 1:
	i = (x - 1) / 5 + 1
if x % 5 == 2:
	i = (x - 2) / 5 + 1
if x % 5 == 3:
	i = (x - 3) / 5 + 1
if x % 5 == 4:
	i = (x - 4) / 5 + 1
print(int(i))


def solve():
	n = int(input())
	cost = 0
	cost += n // 5
	n %= 5
	cost += n // 4
	n %= 4
	cost += n // 3
	n %= 3
	cost += n // 2
	n %= 2
	cost += n // 1
	n %= 1
	print(int(cost))
solve()


coord = int(input())
print(coord // 5 + (coord % 5 != 0))


from sys import stdin, stdout
import math, sys
from itertools import permutations, combinations
from collections import defaultdict, deque, OrderedDict
from os import path
import bisect as bi
import heapq

def yes():
	print('YES')

def no():
	print('NO')
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

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

	def In():
		return map(int, input().split())
else:

	def I():
		return int(stdin.readline())

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

def main():
	try:
		n = I()
		ans = 0
		if n > 0:
			ans += n // 5
			n -= ans * 5
		if n > 0:
			temp = n // 4
			ans += temp
			n -= temp * 4
		if n > 0:
			temp = n // 3
			ans += temp
			n -= temp * 3
		if n > 0:
			temp = n // 2
			ans += temp
			n -= temp * 2
		if n > 0:
			temp = n // 1
			ans += temp
			n -= temp * 1
		print(ans)
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(1):
	main()


xo = int(input())
if xo % 5 == 0:
	print(int(xo / 5))
else:
	print(int(xo / 5) + 1)


import math
dist = int(input())
print(math.ceil(dist / 5))


n = int(input())
a = [1, 2, 3, 4, 5]
if n % 5 == 0:
	print(int(n / 5))
else:
	remainder = n % 5
	n1 = n - remainder
	ans = int(n1 / 5) + 1
	print(ans)


c = int(input())
m = k = 0
for v in range(2, 6):
	m = c % v
	k = c // v
	if c % v <= m:
		m = c % v
		k = c // v
if m == 1 or m == 2 or m == 3 or (m == 4) or (m == 5):
	m = 1
print(m + k)


import math
m = int(input())
print(math.ceil(m / 5))


n = int(input())
if n <= 5:
	print(1)
else:
	for i in range(2, 10 ** 8):
		if 5 * i >= n:
			print(i)
			break
		else:
			continue


e = int(input())
if e % 5 == 0:
	print(e // 5)
else:
	print(e // 5 + 1)


n = int(input())
a = 0
for i in range(5):
	q = 5 - i
	d = int(n / q)
	a += d
	n -= d * q
print(a)


def main():
	x = int(input())
	print(x // 5 + bool(x % 5))
main()


from math import ceil

def main(n):
	return int(ceil(n / 5))
print(main(int(input())))


t = int(input())
c = 0
for i in range(0, t, 5):
	c = c + 1
print(c)


x = int(input())
ans = 0
for i in range(100000000):
	if x <= 5:
		ans += 1
		break
	else:
		x -= 5
		ans += 1
print(ans)


N = int(input())
Cantidad = 0
if N <= 5:
	print(1)
elif N <= 10:
	print(2)
else:
	for k in range(5):
		Cantidad += N // (5 - k)
		N = N % (5 - k)
		if N == 0:
			print(Cantidad)
			break


def get_steps(available_steps, x):
	steps_taken = []
	current_position = 0
	for step_length in available_steps:
		has_gone_past = False
		while has_gone_past is False:
			if current_position + step_length <= x:
				steps_taken.append(step_length)
				current_position += step_length
				if current_position == x:
					return len(steps_taken)
			else:
				has_gone_past = True

def main():
	available_steps = [5, 4, 3, 2, 1]
	x = int(input())
	amount_of_steps = get_steps(available_steps, x)
	print(amount_of_steps)
main()


friend = int(input())
elephant = 0
sol = 0
while elephant < friend:
	if friend - elephant >= 5:
		elephant += 5
	elif friend - elephant >= 4:
		elephant += 4
	elif friend - elephant >= 3:
		elephant += 3
	elif friend - elephant >= 2:
		elephant += 2
	else:
		elephant += 1
	sol += 1
print(sol)


k = int(input())
i = 1
c = k // 5
if k % 5 != 0:
	print(c + 1)
else:
	print(c)


import math
a = int(input())
result = math.ceil(a / 5)
print(result)


corr = int(input())
if not corr % 5:
	print(corr // 5)
else:
	print(corr // 5 + 1)


n = int(input())
path = 0
for i in range(n):
	if n >= 5:
		n = n - 5
		path += 1
		if n == 0:
			print(path)
			exit(0)
	elif n >= 4:
		n = n - 4
		path += 1
		if n == 0:
			print(path)
			exit(0)
	elif n >= 3:
		n = n - 3
		path += 1
		if n == 0:
			print(path)
			exit(0)
	elif n >= 2:
		n = n - 2
		path += 1
		if n == 0:
			print(path)
			exit(0)
	else:
		n = n - 1
		path += 1
		if n == 0:
			print(path)
			exit(0)


num = int(input())
answer = 0
while num != 0:
	if num > 4:
		num -= 5
	elif num > 3:
		num -= 4
	elif num > 2:
		num -= 3
	elif num > 1:
		num -= 2
	else:
		num -= 1
	answer += 1
print(answer)


n = input()
n = int(n)
l = 3
r = 2
t = 4
f = 5
print(n // 5 + (n % 5 != 0))


n = int(input())
s = n // 5
if n > 5 and n % 5 == 0:
	print(s)
elif n > 5 and n % 5 != 0:
	print(s + 1)
else:
	print(1)


import math
import os
import random
import re
import sys
steps = (5, 4, 3, 2, 1)

def solve(n):
	stepsCount = 0
	while n > 0:
		for step in steps:
			if n >= step:
				stepsCount += 1
				n -= step
				break
	return stepsCount
n = int(input())
print(solve(n))


x = int(input())
moves = int(x / 5)
if x % 5 == 0:
	print(moves)
else:
	print(moves + 1)


a = int(input(''))
b = int(a / 5)
if 5 * b != a:
	b += 1
print(b)


x = int(input())
steps = 0
for y in range(5, 0, -1):
	steps += int(x / y)
	x = x % y
print(steps)


n = int(input())
if n <= 5:
	print('1')
elif n > 5:
	count = 0
	while n >= 5:
		n = n - 5
		count = count + 1
	if n == 0:
		print(count)
	else:
		print(count + 1)


x = int(input())
steps = [5, 4, 3, 2, 1]
count = 0
for i in steps:
	while x >= i:
		x -= i
		count += 1
	if x < i:
		continue
	elif x == 0:
		break
print(count)


space = int(input())
if space % 5 == int('0'):
	print(int(space / 5))
else:
	print(int(space / 5) + 1)


itr = 0
n = int(input())
while n > 5:
	itr += 1
	n -= 5
print(itr + 1)


m = int(input())
s = 0
s = s + m // 5
m = m % 5
s = s + m // 4
m = m % 4
s = s + m // 3
m = m % 3
s = s + m // 2
m = m % 2
s = s + m
print(s)


num = int(input())
res = 0
for div in [5, 4, 3, 2, 1]:
	res += num // div
	num %= div
print(res)


location = int(input())
print(int((location + 4) / 5))


x = int(input())
t = x // 5
d = x % 5
if x == 1:
	ans = 1
elif x == 2:
	ans = 1
elif x == 3:
	ans = 1
elif x == 4:
	ans = 1
elif d == 0:
	ans = t
elif d != 0:
	ans = t + 1
print(ans)


(z, zz) = (input, lambda : list(map(int, z().split())))
zzz = lambda : [int(i) for i in stdin.readline().split()]
(szz, graph, mod, szzz) = (lambda : sorted(zz()), {}, 10 ** 9 + 7, lambda : sorted(zzz()))
from string import *
from re import *
from collections import *
from queue import *
from sys import *
from collections import *
from math import *
from heapq import *
from itertools import *
from bisect import *
from collections import Counter as cc
from math import factorial as f
from bisect import bisect as bs
from bisect import bisect_left as bsl
from itertools import accumulate as ac
from itertools import permutations as permu

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def prime(x):
	p = ceil(x ** 0.5) + 1
	for i in range(2, p):
		if x % i == 0 and x != 2 or x == 0:
			return 0
	return 1

def dfs(u, visit, graph):
	visit[u] = True
	for i in graph[u]:
		if not visit[i]:
			dfs(i, visit, graph)
n = int(z())
k = 0
if n % 5:
	k = 1
print(n // 5 + k)


x = int(input())
out = 0
out += x // 5
x = x % 5
out += x // 4
x = x % 4
out += x // 3
x = x % 3
out += x // 2
x = x % 2
out += x // 1
x = x % 1
print(out)


x = int(input())
step_size = [1, 2, 3, 4, 5]
count = 0
if x in step_size:
	count += 1
else:
	while x > step_size[4]:
		x = x - step_size[4]
		count = count + 1
		if x in step_size:
			count = count + 1
print(count)


location = int(input())
step = 0
for i in range(5, 0, -1):
	if location / i >= 1:
		step += location // i
		location = location % i
print(step)


x = int(input())
y = (1, 2, 3, 4, 5)
c = 0
while x != 0:
	if x >= 5:
		x = x - 5
		c += 1
	elif x == 4:
		x = x - 4
		c = c + 1
	elif x == 3:
		x = x - 3
		c = c + 1
	elif x == 2:
		x = x - 2
		c = c + 1
	else:
		x = x - 1
		c = c + 1
print(c)


def met(n):
	if n % 5 == 0:
		return n // 5
	return n // 5 + 1
n = int(input())
print(met(n))


import math
a = {}
c = 0
b = int(input())
i = 0
j = 0
c = math.ceil(b / 5)
print(c)


x = int(input())
a = int(x / 5)
m = x - 5 * a
b = int(m / 4)
n = m - 4 * b
c = int(n / 3)
k = n - 3 * c
d = int(k / 2)
e = k - 2 * d
print(a + b + c + d + e)


x = float(input())
contador = 0
while x >= 5:
	x -= 5
	contador = contador + 1
if x > 0:
	print(contador + 1)
else:
	print(contador)


import math
n = int(input())
sum = 0
sum += math.floor(n / 5)
n %= 5
sum += math.floor(n / 4)
n %= 4
sum += math.floor(n / 3)
n %= 3
sum += math.floor(n / 2)
n %= 2
sum += n
print(sum)


a = input().split()
n = int(a[0])
pos = 0
cnt = 0
while pos != n:
	cnt += 1
	if n - pos >= 5:
		pos += 5
	elif n - pos >= 4:
		pos += 4
	elif n - pos >= 3:
		pos += 3
	elif n - pos >= 2:
		pos += 2
	elif n - pos >= 1:
		pos += 1
print(cnt)


import math
location = input()
r = int(location)
c = 0
steps = [5, 4, 3, 2, 1]
for s in steps:
	a = r / s
	c += math.floor(a)
	if math.floor(a) == 0:
		continue
	r = r % (math.floor(a) * s)
	if r == 0:
		break
print(c)


n = int(input())
ans = n // 5 + (n % 5 != 0)
print(ans)


x = int(input())
total = x // 5
if x % 5 == 0:
	print(total)
else:
	print(total + 1)


friend_location = int(input())
just_one = [1, 2, 3, 4, 5]
steps = []
rem = 6

def function():
	if friend_location in just_one:
		steps.append(1)
	else:
		pass
if friend_location <= 5:
	function()
elif friend_location > 5:
	while rem > 5:
		rem = friend_location % 5
		quo = int(friend_location / 5)
		steps.append(quo)
		friend_location = rem
	function()
print(sum(steps))


road = int(input())
steps = 0
mstep = 5
while road != 0:
	steps += road // mstep
	road %= mstep
	mstep -= 1
print(steps)


n = int(input())
m = 5
count = 0
while m <= 5 and m >= 1:
	count += n // m
	n = n % m
	m -= 1
print(count)


inp = int(input())
out = (inp - 1) // 5
print([out + 1, 1][out == 0])


import math
n = int(input())
if n == 1 or n == 2 or n == 3 or (n == 4) or (n == 5):
	print(1)
else:
	m = n / 5
	print(math.ceil(m))


distance = int(input())
minimum = distance // 5
if distance % 5 != 0:
	minimum += 1
print(minimum)


x = int(input())
move = x // 5
step = x % 5
if step != 0:
	move += 1
print(move)


x = int(input())
q = 0
p = 0
while 0 < 1:
	if q < x and q + 5 <= x:
		q = q + 5
		p = p + 1
	elif q < x and q + 4 <= x:
		q = q + 4
		p = p + 1
	elif q < x and q + 3 <= x:
		q = q + 3
		p = p + 1
	elif q < x and q + 2 <= x:
		q = q + 2
		p = p + 1
	elif q < x and q + 1 <= x:
		q = q + 1
		p = p + 1
	else:
		break
print(p)


n = int(input())
g = 0
while n >= 5:
	n -= 5
	g = g + 1
while n >= 4:
	n -= 4
	g = g + 1
while n >= 3:
	n -= 3
	g = g + 1
while n >= 2:
	n -= 2
	g = g + 1
while n >= 1:
	n -= 1
	g = g + 1
print(g)


n = int(input())
l = [1, 2, 3, 4, 5]
z = 0
for i in range(5):
	if n > 0:
		t = n // l[-(i + 1)]
		z += t
	n = n - l[-(i + 1)] * t
print(z)


n = int(input())
x = 0
if n <= 5:
	print(1)
else:
	x = n / 5
	if int(x % 1 * 10) == 0:
		print(int(x))
	else:
		print(int(x + 1))


from math import ceil
n = int(input())
c = ceil(n / 5)
print(c)


number = int(input())
result = int(number / 5)
if number - int(number / 5) * 5 > 0:
	result += 1
print(result)


n = int(input())
limit = 5
count = 0
while n > 0:
	if limit <= n:
		n = n - limit
		count += 1
	else:
		limit = limit - 1
print(count)


steps = [5, 4, 3, 2, 1]
x = int(input())
count = 0
for s in steps:
	while x // s > 0:
		count += x // s
		x = x % s
print(count)


steps = (5, 4, 3, 2, 1)

def solve(distance):
	moves = 0
	while distance:
		for step in steps:
			if distance >= step:
				moves += 1
				distance -= step
				break
	return moves
distance = int(input())
print(solve(distance))


num1 = int(input())
rem = num1 % 5
if rem == 0:
	print(num1 // 5)
else:
	print(num1 // 5 + 1)


n = int(input())
tot = 0
pasos = 0
for cada in reversed(range(1, 6)):
	pasos = int(n / cada)
	tot += pasos
	n = n - pasos * cada
print(tot)


x = int(input())
steps = 0
while True:
	if x > 5:
		steps += x // 5
		x -= 5 * (x // 5)
	else:
		for el in [1, 2, 3, 4, 5]:
			if x == el:
				steps += 1
				break
		break
print(steps)


n = int(input())

def solve(n):
	counter = 0
	tmp = 5
	while n > 0:
		counter += int(n / tmp)
		n = n % tmp
		tmp -= 1
	print(counter)
solve(n)


p = int(input())
f = p // 5
s = p % 5
if s == 0:
	print(f)
else:
	print(f + 1)


import math
x = int(input())
if x <= 5:
	print(1)
else:
	p = x / 5
	print(math.ceil(p))


x = input()

def getNumberOfSteps(x):
	x = int(x)
	numberOfSteps = 0
	while x > 0:
		numberOfSteps += 1
		x -= 5
	return numberOfSteps
print(getNumberOfSteps(x))


n = int(input())
if n <= 5:
	r = 1
elif n % 5 == 0:
	r = n // 5
else:
	r = n // 5 + 1
print(r)


s = int(input())
step = 0
for i in range(s):
	if s is 5:
		step = step + 1
		break
	elif s is 4:
		step = step + 1
		break
	elif s is 3:
		step = step + 1
		break
	elif s is 2:
		step = step + 1
		break
	elif s is 1:
		step = step + 1
		break
	s = s - 5
	step = step + 1
print(step)


c = 0
n = int(input())
li = [5, 4, 3, 2, 1]
for i in li:
	while n - i >= 0:
		n = n - i
		c += 1
print(c)


from sys import stdin
x = int(stdin.readline().rstrip())
print(x // 5 + bool(x % 5))


def func(x):
	if x % 5 != 0:
		ans = x // 5 + 1 if x > 5 else 1
	else:
		ans = x / 5
	return int(ans)
print(func(int(input())))


a = int(input())
c = 1
while a > 5:
	c += 1
	a -= 5
print(c)


n = int(input())
moves = [1, 2, 3, 4, 5]
k = 0
while n:
	i = 4
	while i >= 0:
		if n >= moves[i]:
			n -= moves[i]
			k += 1
			break
		i -= 1
print(k)


n = int(input())
if n >= 1 and n <= 5:
	print('1')
elif n > 5 and n % 5 == 0:
	print(n // 5)
else:
	d = n // 5
	print(d + 1)


positions = int(input())
ans = positions // 5
if positions % 5 > 0:
	ans += 1
print(ans)


t = int(input())
c = 0
while t > 0:
	t = t - 5
	c = c + 1
print(c)


import math
s = float(input())
print(math.ceil(s / 5))


data = int(input())
result = 0
if data > 5:
	while data > 5:
		data -= 5
		result += 1
	if data > 0:
		result += 1
else:
	result += 1
print(result)


import math
n = abs(int(input()))
print(math.ceil(n / 5))


foo = int(input())
if foo <= 5:
	print(1)
elif foo % 5 == 0:
	print(foo // 5)
else:
	print(foo // 5 + 1)


x = int(input())
res = 0
STEPS = [5, 4, 3, 2, 1]
for i in STEPS:
	if i > x:
		continue
	res += x // i
	x = x % i
print(res)


x = int(input())
m = int(x / 5) + 1
if x % 5 == 0:
	m += -1
print(m)


import math as m
n = int(input())
l = []
for i in range(1, 6):
	l.append(m.ceil(n / i))
print(min(l))


from sys import stdin

def main():
	inpt = [int(x) for x in stdin.read().split(' ')]
	x = inpt[0]
	i = 0
	steps = 0
	while i < x:
		i += 5
		steps += 1
	print(steps)
main()


n = int(input())
r = 0
while n > 0:
	r += 1
	if n > 5:
		n -= 5
	else:
		break
print(r)


import math
dibil = int(input())
print(math.ceil(dibil / 5))


n = int(input())
ans = 0
for i in range(5, 0, -1):
	if n == 0:
		print(ans)
		exit()
	if n // i == 0:
		continue
	ans += n // i
	n -= n // i * i
print(ans)


TN = 1

def solution():
	x = int(input())
	ans = x // 5
	if x % 5:
		ans += 1
	print(ans)
while TN != 0:
	solution()
	TN -= 1


steps = 0
point = int(input())
i = 5
while point != 0 or i == 5:
	if point >= i:
		point = point - i
		steps = steps + 1
		continue
	i = i - 1
print(steps)


x = int(input())
nCount = 0
while 1:
	x -= 5
	if x > 0:
		nCount += 1
	else:
		break
print(nCount + 1)


N = int(input())
S = 0
while N > 0:
	if N >= 5:
		N -= 5
	elif N == 4:
		N -= 4
	elif N == 3:
		N -= 3
	elif N == 2:
		N -= 2
	else:
		N -= 1
	S += 1
print(S)


slon = 0
minimum = 0
x = int(input())
while slon != x:
	if x - slon >= 5:
		slon += 5
		minimum += 1
	else:
		slon = x
		minimum += 1
print(minimum)


n = int(input())
steps = [5, 4, 3, 2, 1]
i = 5
way = 0
while n > 0:
	if n - i >= 0:
		way += 1
		n -= i
	else:
		i -= 1
print(way)


import math
x = int(input())
c = [5, 4, 3, 2, 1]
s = 0
p = 0
while 1:
	for m in c:
		if m <= x:
			s += math.floor(x / m)
			x = x % m
			break
	if x == 0:
		break
print(s)


s = int(input())
d = 0
while s >= 5:
	s -= 5
	d += 1
if s != 0:
	d += 1
print(d)


dist = input()
dist = int(dist)
steps = 0
while dist > 0:
	if dist % 5 >= 0 and dist % 5 != dist:
		steps += int(dist / 5)
		dist = dist % 5
	elif dist % 4 >= 0 and dist % 4 != dist:
		steps += int(dist / 4)
		dist = dist % 4
	elif dist % 3 >= 0 and dist % 3 != dist:
		steps += int(dist / 3)
		dist = dist % 3
	elif dist % 2 >= 0 and dist % 2 != dist:
		steps += int(dist / 2)
		dist = dist % 2
	elif dist % 1 >= 0 and dist % 1 != dist:
		steps += int(dist / 1)
		dist = dist % 1
print(steps)


n = int(input())
j = 0
j = j + n // 5
n = n % 5
j = j + n // 4
n = n % 4
j = j + n // 3
n = n % 3
j = j + n // 2
n = n % 2
j = j + n // 1
n = n % 1
print(j)


count = 0
D = int(input())
if 0 < D <= 5:
	count = 1
else:
	if D % 5 == 0:
		r = 0
	else:
		r = 1
	count = (D - D % 5) // 5 + r
print(count)


t = int(input())
countt = 1
while t > 5:
	countt += 1
	t -= 5
print(countt)


X = int(input())
if X % 5 == 0:
	print(X // 5)
else:
	print(X // 5 + 1)


nums = input().split(' ')
nums = int(nums[0])
lens = [1, 2, 3, 4, 5]
if nums <= 5:
	print('1')
elif nums > 5:
	if nums % 5 == 0:
		print(nums // 5)
	elif nums % 5 != 0:
		print(int(nums // 5 + 1))


prompt = int(input())
count = prompt // 5
if prompt % 5 != 0:
	count += 1
print(count)


import math
import sys
import string

def ri():
	return input()

def ii():
	return int(input())

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

def mi():
	return list(map(int, input().split()))
x = ii()
c = 0
for i in range(5, 0, -1):
	rem = x % i
	if rem < 0:
		continue
	else:
		c += x // i
		x = rem
print(c)


num = int(input())
result = 0
while num >= 5:
	num = num - 5
	result = result + 1
if num == 0:
	print(result)
else:
	print(result + 1)


x = int(input())
d = [1, 2, 3, 4, 5]
s = 0
while x > 0:
	t = d.pop()
	s += x // t
	x = x % t
print(s)


from math import ceil
x = int(input())
if x < 5:
	print('1')
else:
	print(ceil(x / 5))


houseCoord = int(input())
cont = 0
while houseCoord != 0:
	if houseCoord >= 5:
		houseCoord -= 5
		cont += 1
	elif houseCoord >= 4:
		houseCoord -= 4
		cont += 1
	elif houseCoord >= 3:
		houseCoord -= 3
		cont += 1
	elif houseCoord >= 2:
		houseCoord -= 2
		cont += 1
	else:
		houseCoord -= 1
		cont += 1
print(cont)


take = int(input())
steps = [1, 2, 3, 4, 5]
z = []
if take in steps:
	print(1)
else:
	for x in steps:
		xyz = take / x
		z.append(xyz)
	result = min(z)
	if result % 1 > 0:
		print(int(min(z)) + 1)
	elif result != float:
		print(int(result))


length = int(input())
n_steps = 0
while length > 0:
	for i in range(5, 0, -1):
		if length >= i:
			length -= i
			n_steps += 1
			break
print(n_steps)


x = input()
x = int(x)
if x >= 5:
	if x % 5 == 0:
		x = x / 5
	else:
		x = x // 5 + 1
else:
	x = 1
print('{:.0f}'.format(x))


cord = int(input())
steps = cord // 5
if cord % 5:
	steps += 1
print(steps)


pasos = int(input())
p = 0
while pasos > 0:
	if pasos >= 5:
		p += 1
		pasos -= 5
	elif pasos >= 4:
		p += 1
		pasos -= 4
	elif pasos >= 3:
		p += 1
		pasos -= 3
	elif pasos >= 2:
		p += 1
		pasos -= 2
	elif pasos >= 1:
		p += 1
		pasos -= 1
print(p)


user = int(input())
steps = 0
if user // 5:
	steps += user // 5
	user = user - user // 5 * 5
if user // 4:
	steps += user // 4
	user = user - user // 4 * 4
if user // 3:
	steps += user // 3
	user = user - user // 3 * 3
if user // 2:
	steps += user // 2
	user = user - user // 2 * 2
if user // 1:
	steps += 1
	user = user - 1
print(steps)


from math import ceil
coordinateOfFriend = int(input())
minimumSteps = ceil(coordinateOfFriend / 5)
print(minimumSteps)


length = int(input())
if length % 5 == 0:
	print(length // 5)
else:
	print(length // 5 + 1)


x = int(input())
m = int(x / 5)
if x % 5 == 0:
	m = m
elif x % 5 == 4:
	m = m + 1
elif x % 5 == 3:
	m = m + 1
elif x % 5 == 2:
	m = m + 1
elif x % 5 == 1:
	m = m + 1
print(m)


a = int(input())
b = a / 5
c = int(b)
if a % 5 != 0:
	c = c + 1
print(c)


distance = int(input())
print(int((distance + 4) / 5))


import sys
steps = 0
friend = 0
for line in sys.stdin:
	friend = int(line)
if friend <= 5:
	print('1')
	sys.exit()
steps = int(friend / 5)
if friend % 5 != 0:
	steps += 1
print(steps)


n = int(input())
pos = [5, 4, 3, 2, 1]
steps = 0
while n > 0:
	for k in pos:
		if n >= k:
			n -= k
			steps += 1
			break
print(steps)


n = int(input())
cnt = 0
cnt = n // 5
if n % 5 > 0:
	cnt += 1
print(cnt)


x = input()
x = int(x)
k = 0
steps = 0
while k != x:
	if x - k >= 5:
		k += 5
		steps += 1
	elif x - k < 5:
		k += x - k
		steps += 1
print(steps)


n = int(input())
i = 5
s = 0
while n > 0:
	s += n // i
	n -= n // i * i
	i = i - 1
print(s)


x = int(input())
d = [x, x, x, x, x]
i = 0
if x == 5 or x == 4 or x == 3 or (x == 2) or (x == 1):
	print('1')
else:
	while 1:
		d[0] -= 5
		if d[0] == 0:
			i += 1
			break
		d[1] -= 4
		if d[1] == 0:
			i += 1
			break
		d[2] -= 3
		if d[2] == 0:
			i += 1
			break
		d[3] -= 2
		if d[3] == 0:
			i += 1
			break
		d[4] -= 1
		if d[4] == 0:
			i += 1
			break
		s = min(d)
		d = [s, s, s, s, s]
		i += 1
	print(i)


x = int(input(''))
p = x % 5
if p == 0:
	z = int(x / 5)
	print(z)
else:
	s = int(x / 5)
	print(s + 1)


end = int(input())

def main():
	if end > 5:
		steps = end // 5
	else:
		return 1
	rest = end - steps * 5
	if rest > 0:
		steps += 1
	return steps
print(main())


x = input()
x = int(x)
count = 0
for j in range(5, 0, -1):
	while x >= j:
		x = x - j
		count = count + 1
print(count)


x = int(input())
l = [1, 2, 3, 4, 5]
i = len(l) - 1
n = 0
while i >= 0:
	while x >= l[i]:
		x -= l[i]
		n += 1
	i -= 1
print(n)


(steps, count) = ([5, 4, 3, 2, 1], 0)
ans = int(input())
for x in steps:
	count += ans // x
	ans %= x
print(count)


n = int(input())
if n % 5 == 0:
	print(n // 5)
else:
	a = n // 5
	b = n % 5
	if b >= 0 and b <= 4:
		print(a + 1)


n = int(input())
i = n / 5
if i != int(i):
	i = int(i) + 1
print(int(i))


step = 0
lenx = int(input())
for i in range(lenx):
	if lenx <= 5:
		step += 1
		break
	else:
		lenx = lenx - 5
		step += 1
print(step)


def ans(x):
	steps = x // 5
	if x % 5:
		steps += 1
	return steps
x = int(input())
print(ans(x))


n = int(input())
h = 0
h += n // 5
n %= 5
h += n // 4
n %= 4
h += n // 3
n %= 3
h += n // 2
n %= 2
h += n
print(h)


t = int(input())
print(t // 5 + t % 5 // 4 + t % 5 % 4 // 3 + t % 5 % 4 % 3 // 2 + t % 5 % 4 % 3 % 2)


n = int(input())

def f(n, x):
	a = (n - n % x) // x
	return a
(a, v) = (f(n, 5), n % 5)
(b, w) = (f(v, 4), v % 4)
(c, x) = (f(w, 3), w % 3)
(d, y) = (f(x, 2), x % 2)
(e, z) = (f(y, 1), y % 1)
print(a + b + c + d + e)


import math
l = [5, 4, 3, 2, 1]

def elephant(a):
	c = 0
	for i in range(len(l)):
		if a >= l[i]:
			c = math.floor(c + a / l[i])
			a = a % l[i]
	print(c)
elephant(int(input()))


x = int(input())
n1 = x // 5
n2 = x % 5 > 0
print(n1 + n2)


moves = [5, 4, 3, 2, 1]
steps = 0
n = int(input())
for i in moves:
	while n - i >= 0:
		n = n - i
		steps += 1
print(steps)


import math
a = int(input())
result = math.floor(a / 5)
if a % 5 > 0:
	print(result + 1)
else:
	print(result)


n = int(input().rstrip())
count = 0
if n >= 5:
	num_move = n // 5
	n -= num_move * 5
	count += num_move
if n == 0:
	print(count)
else:
	print(count + 1)


s = input()
s = int(s)
s = int((s - 1) / 5 + 1)
print(s)


x = int(input().strip())
s = x / 5
print(str(int(s) + (1 if s > int(s) else 0)))


x = int(input(''))
h = x // 5
p = x % 5
if p == 0:
	print(h)
else:
	print(h + 1)


a = int(input())
n = 0
while True:
	n += a // 5
	a %= 5
	if a == 0:
		break
	else:
		n += a // 4
		a %= 4
		if a == 0:
			break
		else:
			n += a // 3
			a %= 3
			if a == 0:
				break
			else:
				n += a // 2
				a %= 2
				n += a
				break
print(n)


distance = int(input())
import math
step = math.ceil(distance / 5)
print(str(step))


a = int(input())
p = 0
while a >= 5:
	a -= 5
	p += 1
while a >= 4:
	a -= 4
	p += 1
while a >= 3:
	a -= 3
	p += 1
while a >= 2:
	a -= 2
	p += 1
while a >= 1:
	a -= 1
	p += 1
print(p)


x = int(input())
z = x // 5
y = x % 5
c = y // 4
v = y % 4
b = v // 3
n = v % 3
m = n // 2
l = n % 2
k = l // 1
print(z + c + b + m + k)


import math
n = int(input())
res = n
ans = math.ceil(res / 5)
print(ans)


x = int(input())
qwerty = 0
a = x // 5
b = x % 5
if b == 5:
	qwerty = qwerty + 1
if b == 4:
	qwerty = qwerty + 1
if b == 3:
	qwerty = qwerty + 1
if b == 2:
	qwerty = qwerty + 1
if b == 1:
	qwerty = qwerty + 1
if b == 5:
	qwerty = qwerty + 1
if b == 6:
	qwerty = qwerty + 2
if b == 7:
	qwerty = qwerty + 2
if b == 8:
	qwerty = qwerty + 2
if b == 9:
	qwerty = qwerty + 2
print(a + qwerty)


n = int(input())
x = n
steps = 0
steps = n // 5
n %= 5
if steps * 5 < x:
	steps += n // 3
	n %= 3
if steps * 5 < x:
	steps += n // 2
	n %= 2
if steps * 5 < x:
	steps += n // 1
	n %= 1
print(steps)


n = int(input())
n_copy = n
n -= 5 * int(n / 5)
if n == 0:
	print(int(n_copy / 5))
else:
	print(int(n_copy / 5) + 1)


x = int(input().strip())
step = 0
while x != 0 and x >= 5:
	x = x - 5
	step += 1
while x != 0 and x >= 4:
	x = x - 4
	step += 1
while x != 0 and x >= 3:
	x = x - 3
	step += 1
while x != 0 and x >= 2:
	x = x - 2
	step += 1
step += x
print(step)


x = int(input())
count = 0
i = 5
while x > 0:
	if int(x / i) != 0:
		count += int(x / i)
		x -= i * int(x / i)
		i -= 1
		continue
	i -= 1
print(count)


n = int(input())
output = 0
if n % 5 == 0:
	output = int(n / 5)
else:
	output = int(n / 5 + 1)
print(output)


def mod():
	x = int(input())
	if x % 5 == 0:
		z = x / 5
	else:
		z = x / 5 + 1
	print(int(z))
mod()


import math
distance = int(input())
divider = 5
print(math.ceil(float(distance / divider)))


x = int(input())
c = 0

def f(x):
	pass
if x >= 5:
	c = x // 5
	if x % 5:
		c += 1
elif x >= 4:
	c = x // 4
	if x % 4:
		c += 1
elif x >= 3:
	c = x // 3
	if x % 3:
		c += 1
elif x >= 2:
	c = x // 2
	if x % 2:
		c += 1
else:
	c = x
print(c)


import sys
inf = float('inf')
mod = 1000000007

def get_array():
	return list(map(int, sys.stdin.readline().split()))

def get_ints():
	return map(int, sys.stdin.readline().split())

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

def int1():
	return int(input())

def main():
	n = int1()
	if n % 5 == 0:
		print(n // 5)
	else:
		print(n // 5 + 1)
main()


a = int(input())
i = 5
c = 0
while a > 0:
	if a // i > 0:
		c += a // i
		a = a - i * c
	i = i - 1
print(c)


n = int(input())
extra = 1 if n % 5 != 0 else 0
print(n // 5 + extra)


user_input = int(input())
res = int(user_input / 5)
if user_input % 5 == 0:
	print(res)
if user_input % 5 != 0:
	print(res + 1)


x = int(input())
c = 0
if x >= 5:
	c = c + int(x / 5)
	x = x - int(x / 5) * 5
if x >= 4:
	c = c + x / 4
	x = x - int(x / 4) * 4
if x >= 3:
	c = c + x / 3
	x = x - int(x / 3) * 3
if x >= 2:
	c = c + x / 2
	x = x - int(x / 2) * 2
if x >= 1:
	c = c + x
print(int(c))


s = int(input())
t = int(s / 5)
t = t + int(s % 5 / 4)
s = s % 5
t = t + int(int(s % 4) / 3)
s = s % 4
t = t + int(int(s % 3) / 2)
s = s % 3
t = t + int(int(s % 2) / 1)
s = s % 2
t = t + int(int(s % 1) / 1)
print(t)


num = int(input())
total = 0
if num % 5 == 0:
	total += num / 5
	num = 0
else:
	total += int(num / 5)
	num = num % 5
if num % 4 == 0 and num != 0:
	total += num / 4
	num = 0
else:
	total += int(num / 4)
	num = num % 4
if num % 3 == 0 and num != 0:
	total += num / 3
	num = 0
else:
	total += int(num / 3)
	num = num % 3
if num % 2 == 0 and num != 0:
	total += num / 2
	num = 0
else:
	total += int(num / 2)
	num = num % 2
if num % 1 == 0 and num != 0:
	total += num / 1
	num = 0
else:
	total += int(num / 1)
print(int(total))


x = int(input())
if x <= 5:
	print(1)
if x > 5:
	print((x + 4) // 5)


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
N = int(input())
if N % 5 == 0:
	print(N // 5)
else:
	print(N // 5 + 1)


t = int(input())
min = 0
l = [5, 4, 3, 2, 1]
i = 0
while t > 0:
	if l[i] > t:
		i += 1
	min = min + t // l[i]
	t = t % l[i]
print(min)


n = int(input())
from math import *
k = ceil(n / 5)
print(k)


def self():
	a = int(input())
	i = 0
	k = 0
	while i < a:
		if i + 5 <= a:
			i += 5
			k += 1
		elif i + 4 <= a:
			i += 4
			k += 1
		elif i + 3 <= a:
			i += 3
			k += 1
		elif i + 2 <= a:
			i += 2
			k += 1
		elif i + 1 <= a:
			i += 1
			k += 1
	print(k)
self()


x = int(input())
pos = sum = 0
while pos != x:
	if x - pos >= 5:
		sum += 1
		pos += 5
	elif x - pos >= 4:
		sum += 1
		pos += 4
	elif x - pos >= 3:
		sum += 1
		pos += 3
	elif x - pos >= 2:
		sum += 1
		pos += 2
	else:
		sum += 1
		pos += 1
print(sum)


n = int(input())
cout = 0
for i in range(5, 0, -1):
	if n == 0:
		break
	else:
		cout += n // i
		n = n - n // i * i
print(cout)


n = int(input())
arr = (5, 4, 3, 2, 1)
total = 0
step = 0
for i in arr:
	while total < n:
		total += i
		step += 1
print(step)


def check(x):
	c = 0
	while x != 0:
		if x in [1, 2, 3, 4, 5]:
			x -= x
		else:
			x -= 5
		c += 1
	return c
x = int(input())
print(check(x))


house = int(input())
position = 0
step = 0
while position + 5 <= house:
	position = position + 5
	step = step + 1
while position + 4 <= house:
	position = position + 4
	step = step + 1
while position + 3 <= house:
	position = position + 3
	step = step + 1
while position + 2 <= house:
	position = position + 2
	step = step + 1
while position + 1 <= house:
	position = position + 1
	step = step + 1
print(step)


n = int(input())
steps = 0
for _ in range(5, 0, -1):
	steps += int(n / _)
	n = n % _
print(steps)


l = [5, 4, 3, 2, 1]
ans = 0
n = int(input())
for i in l:
	if n // i == 0:
		continue
	ans += n // i
	n -= ans * i
	if n < 0:
		break
print(ans)


k = input()
k = int(k)
x = 0
x = k // 5
if k % 5 != 0:
	k = k % 5
	x += k // 4
	if k % 4 != 0:
		k = k % 4
		x += k // 3
		if k % 3 != 0:
			k = k % 3
			x += k // 2
			if k % 2 != 0:
				k = k % 2
				x += 1
print(x)


x = [5, 4, 3, 2, 1]
n = int(input().strip())
c = 0
for i in range(5):
	while n >= x[i]:
		c = c + n // x[i]
		n = n % x[i]
print(c)


num = int(input())
val = 0
if num % 5 != 0:
	val = 1
print(num // 5 + val)


x = int(input())
step1 = 0
step2 = 0
flag = 0
new = 0
for i in range(1, 6):
	if x % i == 0:
		step1 = x // i
		flag = 1
step2 = x // 5 + 1
if flag == 1:
	print(min(step1, step2))
else:
	print(step2)


moves = [1, 2, 3, 4, 5]
n = int(input())
num = 0
i = len(moves) - 1
while i >= 0:
	move = moves[i]
	if n < move:
		i -= 1
	else:
		num += int(n / move)
		n %= move
		i -= 1
print(num)


input_num = int(input())
result = 0
remainder = 0
remainder = input_num % 5
if remainder < input_num:
	result += (input_num - remainder) / 5
	input_num = remainder
remainder = input_num % 4
if remainder < input_num:
	result += (input_num - remainder) / 4
	input_num = remainder
remainder = input_num % 3
if remainder < input_num:
	result += (input_num - remainder) / 3
	input_num = remainder
remainder = input_num % 2
if remainder < input_num:
	result += (input_num - remainder) / 2
	input_num = remainder
remainder = input_num % 1
if remainder < input_num or remainder == 1:
	result += (input_num - remainder) / 1
	input_num = remainder
print(int(result))


n = input()
n = int(n)
lst = [1, 2, 3, 4, 5]
res = 0
while n > 0:
	if n - lst[4] >= 0:
		res += 1
		n -= lst[4]
	elif n - lst[3] >= 0:
		res += 1
		n -= lst[3]
	elif n - lst[2] >= 0:
		res += 1
		n -= lst[2]
	elif n - lst[1] >= 0:
		res += 1
		n -= lst[1]
	elif n - lst[0] >= 0:
		res += 1
		n -= lst[0]
print(res)


n = int(input())
a = [1, 2, 3, 4, 5]
b = []
for i in range(len(a)):
	if n % a[i] == 0:
		b.append(n // a[i])
	else:
		b.append(n // a[i] + 1)
print(min(b))


sayi = int(input())
a = int(sayi / 5)
if sayi % 5 == 0:
	print(a)
else:
	print(a + 1)


from math import ceil
n = int(input())
print(n // 5 + ceil(n % 5 / 5) * 1)


x = int(input())
if x % 5 == 0:
	t = x // 5
	print(t)
elif x % 5 != 0:
	t = x // 5
	print(t + 1)


x = int(input())
sh = x
num = 0
flag = 0
h = [5, 4, 3, 2, 1]

def ope(sh, i):
	if sh - i >= 0:
		sh -= i
		return (sh, 1)
	else:
		return (sh, 0)
while sh > 0:
	for i in h:
		(sh, flag) = ope(sh, i)
		if flag == 1:
			num += 1
			break
print(num)


a = int(input())
b = a % 5
if a > 5:
	if b == 0:
		b = a / 5
	else:
		b = a / 5 + 1
elif a > 0:
	b = 1
else:
	b = 0
print(int(b), end='')


def solve():
	n = int(input())
	ret = n // 5
	if n % 5 != 0:
		ret += 1
	print(ret)
solve()


import math
coordinate = int(input())
print(math.ceil(coordinate / 5))


n = int(input())
totalSteps = 0
if n <= 5:
	totalSteps = 1
elif n % 5 == 0:
	totalSteps = n // 5
else:
	totalSteps = n // 5 + 1
print(totalSteps)


x = int(input())
a = [5, 4, 3, 2, 1]
c = 0
for i in range(5):
	if x % a[i] >= 0 and x % a[i] != x:
		c += x // a[i]
		x -= x // a[i] * a[i]
print(c)


import os
import sys
from io import BytesIO, IOBase

def main():
	pass
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))
input = lambda : sys.stdin.readline().rstrip('\r\n')
import math
AllSteps = []
x = int(input())
i = 5
while i > 0:
	steps = math.ceil(x / i)
	AllSteps.append(steps)
	i -= 1
print(min(AllSteps))


try:
	n = int(input())
	a = n % 5
	if a == 0:
		n = n + a
	else:
		n = n + (5 - a)
	b = n // 5
	print(b)
except:
	pass


from sys import stdin, stdout
house = int(input())
steps = [5, 4, 3, 2, 1]
i = 0
count = 0
while house != 0:
	if house < steps[i]:
		i += 1
		continue
	else:
		count += house // steps[i]
		house = house % steps[i]
print(count)


STEPS = [1, 2, 3, 4, 5]
STEPS.sort()

def main():
	distance_ = int(input())
	remainingDist = distance_
	nSteps = 0
	for step in reversed(STEPS):
		nSteps += remainingDist // step
		remainingDist -= step * (remainingDist // step)
		if not remainingDist % step:
			break
	print(nSteps)
	return nSteps
main()


import math

class Solution617A:

	def __init__(self):
		self.length = 0
		self.result = 0

	def parse_input(self):
		self.length = int(input())

	def solve(self):
		self.result = math.ceil(self.length / 5)

	def get_result(self):
		return str(self.result)
solution = Solution617A()
solution.parse_input()
solution.solve()
print(solution.get_result())


steps = int(input())

def step(st, ssize):
	s = st // ssize
	st = steps % ssize
	return (s, st)
(s5, steps) = step(steps, 5)
(s4, steps) = step(steps, 4)
(s3, steps) = step(steps, 3)
(s2, steps) = step(steps, 2)
(s1, steps) = step(steps, 1)
print(s5 + s4 + s3 + s2 + s1)


n = int(input())
r = n % 5
m = n // 5
if r == 0:
	print(m)
else:
	print(m + 1)


num = int(input())
steps = 0
cur = num
checks = [5, 4, 3, 2, 1]
for x in checks:
	steps += int(cur / x)
	cur = cur % x
print(steps)


x = int(input())
cnt = x // 5
if x % 5 > 0:
	cnt += 1
print(cnt)


xx = int(input())
if xx % 5 == 0:
	print(xx // 5)
else:
	print(xx // 5 + 1)


import math
from collections import defaultdict
from collections import Counter
import itertools

def solve(n):
	return math.ceil(n / 5)
n = int(input())
print(solve(n))


import math
x = int(input())

def get_steps(n):
	steps = int(math.ceil(n / 5))
	return steps
out = get_steps(x)
print(out)


a = int(input())
b = 0
while a > 0:
	a -= 5
	b += 1
while a > 0:
	a -= 4
	b += 1
while a > 0:
	a -= 3
	b += 1
while a > 0:
	a -= 2
	b += 1
while a > 0:
	a -= 1
	b += 1
print(b)


x = int(input())
e = 0
while x >= 5:
	x -= 5
	e += 1
while x >= 4:
	x -= 4
	e += 1
while x >= 3:
	x -= 3
	e += 1
while x >= 2:
	x -= 2
	e += 1
while x >= 1:
	x -= 1
	e += 1
print(e)


a = int(input())
counter = 0
while a > 0:
	counter += 1
	a = a - 5
print(counter)


n = int(input().strip())
l = [5, 4, 3, 2, 1]
i = 0
c = 0
while n > 0 and i <= 5:
	if n - l[i] >= 0:
		n = n - l[i]
		c = c + 1
	else:
		i = i + 1
print(c)


x = int(input())
kol1 = 0
kol5 = x // 5
x = x - kol5 * 5
kol4 = x // 4
x = x - kol4 * 4
kol3 = x // 3
x = x - kol3 * 3
kol2 = x // 2
x = x - kol2 * 2
if x == 1:
	kol1 += 1
kol = kol5 + kol4 + kol3 + kol2 + kol1
print(kol)


n = int(input())
moves = 0
moves += n // 5
n %= 5
moves += n // 4
n %= 4
moves += n // 3
n %= 3
moves += n // 2
n %= 2
moves += n // 1
n %= 1
print(moves)


length = int(input())
counter = 0
if length % 5 == 0 or length == 0:
	print(length // 5)
else:
	print(length // 5 + 1)


n = int(input())
x = 0
for i in range(n, n + 6):
	if i % 5 == 0:
		x = i
		break
print(int(x / 5))


entered_count = int(input())
count_of_steps = 0
while entered_count > 0:
	for i in range(5, 0, -1):
		if entered_count - i >= 0:
			count_of_steps += 1
			entered_count -= i
			break
print(count_of_steps)


x = int(input())
count = 0
steps = [1, 2, 3, 4, 5]
for step in reversed(steps):
	while x > 0:
		x -= step
		count += 1
print(count)


x = int(input())
m = [5, 4, 3, 2, 1]
step = 0
for i in range(len(m)):
	step += x // m[i]
	x = x % m[i]
print(step)


x = int(input())
i = 0
while x > i:
	if x >= 5:
		(x, y) = (x // 5, x % 5)
		if 3 < y <= 4:
			z = y // 4
			print(x + z)
		elif 2 < y <= 3:
			z = y // 3
			print(x + z)
		elif 1 < y <= 2:
			z = y // 2
			print(x + z)
		elif 0 < y <= 1:
			z = y // 1
			print(x + z)
		else:
			print(x)
	elif x <= 4:
		print(x - (x - 1))
	break


number = int(input())
counter = 0
while True:
	if int(number / 5) != 0:
		number -= 5
		counter += 1
	else:
		break
while True:
	if int(number / 4) != 0:
		number -= 4
		counter += 1
	else:
		break
while True:
	if int(number / 3) != 0:
		number -= 3
		counter += 1
	else:
		break
while True:
	if int(number / 2) != 0:
		number -= 2
		counter += 1
	else:
		break
while True:
	if int(number / 1) != 0:
		number -= 1
		counter += 1
	else:
		break
print(counter)


b = int(input())
x = b / 5
a = x
x1 = b % 5
x2 = int(x1 / 4)
a1 = a + x2
x3 = x1 % 4
x4 = int(x3 / 3)
a2 = a1 + x4
x5 = x3 % 3
x6 = int(x5 / 2)
a3 = a2 + x6
x7 = x5 % 2
x8 = int(x7 / 1)
a4 = a3 + x8
print(int(a4))


x = int(input())
step = 0
while x > 0:
	if x % 5 == 0:
		step += x / 5
		x = 0
	elif x % 5 != 0 and x > 5:
		x -= 5
		step += 1
	elif x < 5:
		step += 1
		x = 0
print(int(step))


n = int(input())
if n in range(6):
	print(1)
else:
	c = n // 5
	if n % 5 == 0:
		print(c)
	else:
		print(c + 1)


inp = int(input())
ans = inp / 5
if inp % 5 != 0:
	ans += 1
print(int(ans))


from sys import *

def solver(n):
	cnt = 0
	for i in range(5, 0, -1):
		cnt = cnt + n // i
		n = n % i
	return cnt
n = int(stdin.readline())
stdout.write(str(solver(n)))


d = input()
d = int(d)
if d == 1 or d == 2 or d == 3 or (d == 4) or (d == 5):
	print('1')
elif d % 5 == 0:
	s = d // 5
	print(s)
elif d % 5 != 0:
	s = d // 5 + 1
	print(s)


x = int(input())
y = [5, 4, 3, 2, 1]
a = 0
for i in y:
	if x // i >= 1:
		a += x // i
		x -= x // i * i
	else:
		pass
print(a)


from sys import stdin, stdout

def main() -> None:
	n = int(stdin.read())
	rem = 0
	if n > 5:
		if n % 5 > 0:
			rem = 1
		print(n // 5 + rem)
	else:
		print(1)
	return None
main()


dist = int(input())
steps = [5, 4, 3, 2, 1]
num = 0
for i in steps:
	num += dist // i
	dist -= dist // i * i
print(num)


def contar(x: int, pasos: list):
	i = len(pasos) - 1
	return _contar(x, pasos, i)

def _contar(x, pasos, i):
	if x % pasos[i] == 0:
		return x // pasos[i]
	if x // pasos[i] > 0:
		return x // pasos[i] + _contar(x % pasos[i], pasos, i - 1)
	else:
		return _contar(x, pasos, i - 1)
print(contar(int(input()), [1, 2, 3, 4, 5]))


a = int(input())
q = int(a / 5)
r = int(a % 5)
if r > 0:
	print(q + 1)
else:
	print(q)


n = int(input())
lis = []
if n >= 5:
	if n % 5 == 0:
		final = n // 5
	else:
		final = n // 5 + 1
else:
	final = 1
print(final)


def Elephant(n):
	return int(n / 5 if n % 5 == 0 else n / 5 + 1)
n = int(input())
print(Elephant(n))


house = int(input().strip())
if house < 6:
	print(1)
elif house % 5 > 0:
	print(house // 5 + 1)
else:
	print(house // 5)


coord = int(input(''))
steps = [5, 4, 3, 2, 1]
counter = 0
for step in steps:
	didvizion = coord // step
	counter += didvizion
	ost = coord % step
	coord = ost
print(counter)


x = int(input())
i = 1
t = 0
while x != 0:
	if x >= 5:
		i = int(x / 5)
		x = x - 5 * i
		t = t + i
	elif x >= 4:
		x = x - 4
		t = t + 1
	elif x >= 3:
		x = x - 3
		t = t + 1
	elif x >= 2:
		x = x - 2
		t = t + 1
	else:
		x = x - 1
		t = t + 1
print(t)


def elephant(n):
	if n % 5 == 0:
		return int(n / 5)
	(ele_step, i, all_steps) = ([5, 4, 3, 2, 1], 0, 0)
	while n > 0:
		if n - ele_step[i] >= 0:
			n -= ele_step[i]
			all_steps += 1
		else:
			i += 1
	return all_steps
n = int(input())
print(elephant(n))


st = int(input())
c = 0
i = 0
while c < st:
	c += 5
	i += 1
print(i)


inp = int(input())
steps = 0
while inp >= 5:
	steps += 1
	inp -= 5
if inp != 0:
	steps += 1
print(steps)


a = int(input())
c = 0
c += a // 5
a %= 5
c += a // 4
a %= 4
c += a // 3
a %= 3
c += a // 2
a %= 2
c += a
print(c)


try:
	x = int(input())
	ans = 0
	if x % 5 == 0:
		ans = int(x / 5)
	else:
		ans = int(x / 5) + 1
	print(ans)
except:
	pass


x = int(input())

def f(x):
	i = 0
	while x != 0:
		i += 1
		if x >= 5:
			x -= 5
		elif x == 4:
			x -= 4
		elif x == 3:
			x -= 3
		elif x == 2:
			x -= 2
		elif x == 1:
			x -= 1
	print(i)
f(x)


x = int(input())
w = x / 5
if x % 5 > 0:
	w += 1
print(int(w))


try:
	x = int(input())
	p = [1, 2, 3, 4, 5]
	p = sorted(p, reverse=True)
	c = 0
	i = 0
	while x > 0:
		if x >= p[i]:
			x = x - p[i]
			c += 1
		else:
			i += 1
	print(c)
except:
	pass


x = int(input())
footStep = 0
if x > 4:
	footStep += x // 5
	x -= 5 * (x // 5)
if x > 3:
	footStep += 1
	x -= 4
if x > 2:
	footStep += 1
	x -= 3
if x > 1:
	footStep += 1
	x -= 2
if x > 0:
	footStep += 1
	x -= 1
print(footStep)


x = int(input())
if x > 5:
	if x % 5 > 0:
		stp = int(x / 5) + 1
	else:
		stp = x / 5
else:
	stp = 1
print(int(stp))


a = int(input())
c = a // 5
if a <= 5:
	print(1)
elif a % 5 == 0:
	print(c)
elif a > 5 and a % 5 != 0:
	print(c + 1)


x = int(input())
c = 1
d = 5
while True:
	if x - d > 0:
		x -= d
		c += 1
	elif x - d == 0:
		print(c)
		break
	elif x - d < 0:
		d -= 1
	elif x - d == 0:
		print(c)
		break


n = int(input())
a = n // 5
b = n % 5
if b == 0:
	c = 0
else:
	c = 1
print(a + c)


def main():
	lst = [5, 4, 3, 2, 1]
	pos = int(input())
	(steps, i, count) = (0, 0, 0)
	while steps != pos:
		if steps + lst[i] <= pos:
			steps += lst[i]
			count += 1
		else:
			i += 1
	print(count)
main()


x = int(input())
result = 0
result += int(x / 5)
x = x % 5
result += int(x / 4)
x = x % 4
result += int(x / 3)
x = x % 3
result += int(x / 2)
x = x % 2
result += x
print(result)


x = int(input())
result = int((x - x % 5) / 5)
if x % 5 > 0:
	result += 1
print(result)


lis = [int(x) for x in range(5, 0, -1)]
n = int(input())
count = 0
for i in lis:
	if i <= n:
		count += n // i
		n = n % i
print(count)


dist = int(input())
step = 0
while dist > 5:
	dist = dist - 5
	step = step + 1
steps = step + 1
print(steps)


def distance():
	a = int(input())
	res = 0
	for i in range(0, 5):
		step = a // (5 - i)
		if step == 0:
			continue
		else:
			res += step
			a -= step * (5 - i)
	print(res)
distance()


n = int(input())
if n >= 1 and n <= 5:
	k = 1
	print(k)
else:
	a = 0
	m = 0
	while n - a > 5:
		a += 5
		m += 1
	if a == n:
		print(m)
	else:
		print(m + 1)


coord = int(input())
steps = coord // 5
steps += 1 if coord % 5 != 0 else 0
print(steps)


dist = int(input())
counter = 0
for i in range(5, 0, -1):
	counter = counter + dist // i
	dist = dist % i
print(counter)


import sys
x = int(sys.stdin.readline())
moves = [5, 4, 3, 2, 1]
steps = 0
for move in moves:
	if move <= x:
		(div, mod) = divmod(x, move)
		x = mod
		steps += div
print(str(steps))


cash = int(input())
count = 0
for i in [5, 4, 3, 2, 1]:
	while cash >= i:
		cash -= i
		count += 1
print(count)


dest = input()
dest = int(dest)
out = dest // 5
if dest % 5 != 0:
	out += 1
print(out)


n = int(input())
step = 0
if n > 5 and n % 5 != 0:
	step = step + n // 5 + 1
	print(step)
elif n > 5 and n % 5 == 0:
	step = step + n // 5
	print(step)
else:
	print('1')


X = int(input())
Y = X % 5
if Y == 0:
	N = int(X / 5)
else:
	N = int((X - Y) / 5) + 1
print(N)


dis = int(input())
size = 5
steps = 0
while dis > 0:
	if dis - size >= 0:
		dis -= size
		steps += 1
	else:
		size -= 1
print(steps)


x = int(input())
print(-(-x // 5))


a = int(input())
i = 5
res = 0
while a > 0 and i > 0:
	if a >= i:
		res += a // i
	a = a - a // i * i
	i -= 1
print(res)


a = int(input())
b = 0
steps = 0
while b != a:
	if b + 5 <= a:
		b += 5
		steps += 1
	elif b + 4 <= a:
		b += 4
		steps += 1
	elif b + 3 <= a:
		b += 3
		steps += 1
	elif b + 2 <= a:
		b += 2
		steps += 1
	elif b + 1 <= a:
		b += 1
		steps += 1
print(steps)


x = int(input())
L = [1, 2, 3, 4]
if x > 5 and x // 5 * 5 == x:
	print(x // 5)
elif x <= 5:
	print(1)
else:
	s = x // 5
	print(1 + s)


from sys import exit as sys_return
(moveset, cur_move) = ([5, 4, 3, 2, 1], 0)
(moves, target) = (0, int(input()))
while target != 0:
	if target - moveset[cur_move] >= 0:
		moves += target // moveset[cur_move]
		target %= moveset[cur_move]
	else:
		cur_move += 1
print(moves)


import math

def main():
	n = int(input())
	if n <= 5:
		print('1')
	else:
		print(math.ceil(n / 5))
main()


def steps_count(f_h_located):
	count = 0
	while f_h_located > 0:
		if f_h_located >= 5:
			f_h_located -= 5
		elif f_h_located >= 4:
			f_h_located -= 4
		elif f_h_located >= 3:
			f_h_located -= 3
		elif f_h_located >= 2:
			f_h_located -= 2
		else:
			f_h_located -= 1
		count += 1
	print(count)
x = int(input())
steps_count(x)


home = int(input())
s = 0
s += home // 5
if home % 5 == 0:
	print(s)
else:
	print(s + 1)


x = int(input())
count = 0
if x < 6:
	count = 1
elif x % 5 != 0:
	count = int(x / 5) + 1
else:
	count = int(x / 5)
print(count)


import math
x = int(input())
n5 = math.floor(x / 5)
n4 = math.floor((x - 5 * n5) / 4)
n3 = math.floor((x - 5 * n5 - 4 * n4) / 3)
n2 = math.floor((x - 5 * n5 - 4 * n4 - 3 * n3) / 2)
n1 = x - 5 * n5 - 4 * n4 - 3 * n3 - 2 * n2
n = n1 + n2 + n3 + n4 + n5
print(n)


import math
n = int(input())
s = math.ceil(n / 5)
print(s)


masukan = int(input())
total = 0
while masukan != 0:
	if masukan >= 5:
		masukan -= 5
		total += 1
	elif masukan >= 4:
		masukan -= 4
		total += 1
	elif masukan >= 3:
		masukan -= 3
		total += 1
	elif masukan >= 2:
		masukan -= 2
		total += 1
	elif masukan >= 1:
		masukan -= 1
		total += 1
print(total)


x = int(input())
s = x // 5
if x % 5 == 4:
	s = (x - 4) // 5 + 1
elif x % 5 == 3:
	s = (x - 3) // 5 + 1
elif x % 5 == 2:
	s = (x - 2) // 5 + 1
elif x % 5 == 1:
	s = (x - 1) // 5 + 1
print(s)


from math import floor
steps = int(input())
five = floor(steps / 5)
remaining = steps % 5
if remaining == 0:
	print(five)
else:
	print(five + 1)


step = int(input())
if step <= 5:
	print('1')
elif step % 5 == 0:
	print(int(step / 5))
elif step > 5 and step % 5 != 0:
	print(int(step / 5) + 1)


data = int(input())
if data >= 5 and data % 5 == 0:
	print(data // 5)
elif data < 5:
	print(1)
else:
	print(data // 5 + 1)


friend_house = int(input())
moves = 0
if friend_house % 5 == 0:
	moves = friend_house // 5
else:
	moves = friend_house // 5 + 1
print(moves)


x = int(input())
steps = [5, 4, 3, 2, 1]
count = 0
final_count = 0
for i in steps:
	count += int(x / i)
	x -= count * i
	final_count += count
	count = 0
print(final_count)


x = int(input())
if x >= 5:
	cnt = x
else:
	cnt = 1
while x >= 5:
	cnt = cnt // 5
	x = x % 5
	if x == 0:
		break
	else:
		cnt = cnt + 1
print(cnt)


x = int(input())
(q, r) = divmod(x, 5)
print(q + bool(r))


n = int(input())
if n > 5:
	rem = n % 5
	val = n - rem
	val = val // 5
	if rem == 0:
		print(val)
	else:
		print(val + 1)
else:
	print(1)


x = int(input())
print(int((x - 1e-05) / 5 + 1))


n = int(input())
c = 0
q = n // 5
r = n % 5
c += q
if r == 0:
	print(c)
else:
	q1 = r // 4
	r1 = r % 4
	c += q1
	if r1 == 0:
		print(c)
	else:
		q2 = r1 // 3
		r2 = r1 % 3
		c += q2
		if r2 == 0:
			print(c)
		else:
			q3 = r2 // 2
			r3 = r2 % 2
			c += q3
			if r3 == 0:
				print(c)
			else:
				print(c + 1)


n = int(input())
z = 0
for i in range(1, 6):
	z += n // (6 - i)
	n %= 6 - i
print(z)


x = int(input())
resultat = int(x / 5)
if x % 5 != 0:
	resultat += 1
print(resultat)


n = int(input())
count = 0
for i in reversed(range(1, 6)):
	if n == 0:
		break
	temp = n // i
	count += temp
	n -= i * temp
print(count)


distance = int(input())
result = 0
steps = [5, 4, 3, 2, 1]
for step in steps:
	if distance // step > 0:
		result += distance // step
		distance -= distance // step * step
print(result)


n = int(input())
res = int(n / 5)
if n % 5:
	res += 1
print(res)


a = int(input())
b = int(a / 5)
c = int((a - b * 5) / 4)
d = int((a - b * 5 - c * 4) / 3)
e = int((a - b * 5 - c * 4 - d * 3) / 2)
f = a - b * 5 - c * 4 - d * 3 - e * 2
print(b + c + d + e + f)


x = int(input())
cislo = 1
while cislo * 5 < x:
	if cislo * 5 > x:
		print(cislo + 1)
		break
	cislo += 1
else:
	print(cislo)


import math
house = int(input())
steps = 0
pos = 0
for num in [5, 4, 3, 2, 1]:
	togo = house - pos
	if togo <= 0:
		break
	into = math.floor(togo / num)
	if into > 0:
		steps += into
		pos += into * num
print(steps)


import math
masukan = int(input(''))
print(math.ceil(masukan / 5))


def parse():
	return int(input())

def solve():
	n = parse()
	reste = 0 if n % 5 == 0 else 1
	print(n // 5 + reste)
solve()


x = int(input())
if x <= 5:
	print('1')
else:
	import math
	n0 = math.ceil(x / 5)
	print(n0)


n = int(input())
div = 5
ans = 0
while n != 0 and div != 0:
	ans += n // div
	n %= div
	div -= 1
print(ans)


import math

def main():
	step = int(input())
	if step < 5:
		print(1)
	elif step % 5 == 0:
		print(int(step / 5))
	else:
		step > 5 and step % 5 != 0
		print(int(step / 5 + 1))
main()


x = int(input())
step5 = x // 5
x -= step5 * 5
step4 = x // 4
x -= step4 * 4
step3 = x // 3
x -= step3 * 3
step2 = x // 2
x -= step2 * 2
step1 = x
out = step1 + step2 + step3 + step4 + step5
print(out)


house = int(input())
i = 5
c = 0
while house:
	c += house // i
	house %= i
	i -= 1
print(c)


x = int(input())
ctr = 0

def findQuotientRemainder(x, i):
	bln = False
	quotient = x // i
	remainder = x % i
	if remainder < 0:
		bln = True
	return (quotient, remainder, bln)
for i in range(5, 0, -1):
	(q, r, bln) = findQuotientRemainder(x, i)
	ctr += q
	if bln == False:
		x = r
	else:
		pass
print(ctr)


import math
n = int(input())
count = 0
a = math.floor(n / 5)
n = n - a * 5
count = count + a
a = math.floor(n / 4)
n = n - a * 4
count = count + a
a = math.floor(n / 3)
n = n - a * 3
count = count + a
a = math.floor(n / 2)
n = n - a * 2
count = count + a
a = math.floor(n / 1)
n = n - a * 1
count = count + a
print(count)


i = int(input())
j = i // 5
if i % 5 == 0:
	print(j)
else:
	print(j + 1)


n = int(input())
k = n % 5
ks = n // 5
if k == 0:
	print(ks)
else:
	print(ks + 1)


n = int(input())
s = 0
r = 0
while n % 5 != 0:
	n = n - 1
	r += 1
if n % 5 == 0:
	s += n // 5
if r == 0:
	print(s)
else:
	print(s + 1)


n = int(input())
cnt = 0
li = [1, 2, 3, 4, 5]
s = 0
while s != n:
	if max(li) <= n and s <= n and (abs(s - n) >= max(li)):
		s += max(li)
		cnt += 1
	else:
		li.pop(li.index(max(li)))
print(cnt)


x = int(input())
steps = (x - x % 5) / 5
x = x % 5
steps = steps + (x - x % 4) / 4
x = x % 4
steps = steps + (x - x % 3) / 3
x = x % 3
steps = steps + (x - x % 2) / 2
x = x % 2
steps = steps + (x - x % 1) / 1
x = x % 1
print(int(steps))


a = [5, 4, 3, 2, 1]
n = int(input())
w = n
i = 0
c = 0
while w > 0 and i < len(a):
	if w - a[i] >= 0:
		w = w - a[i]
		c += 1
	else:
		i += 1
print(c)


x = int(input())
steps = 0
while x != 0:
	if (x - 1) % 5 == 0:
		steps += 1
		x -= 1
		continue
	if (x - 2) % 5 == 0:
		steps += 1
		x -= 2
		continue
	if (x - 3) % 5 == 0:
		steps += 1
		x -= 3
		continue
	if (x - 4) % 5 == 0:
		steps += 1
		x -= 4
		continue
	if x % 5 == 0:
		steps = steps + x / 5
		break
print(int(steps))


x = int(input())
(curPos, steps) = (0, 1)
while x - curPos > 5:
	x -= 5
	steps += 1
print(steps)


f = int(input())
c100 = f // 5
c20 = f % 5 // 4
c10 = f % 5 % 4 // 3
c5 = f % 5 % 4 % 3 // 2
c1 = f % 5 % 4 % 3 % 2 // 1
c = c100 + c20 + c10 + c5 + c1
print(c)


import math
x = int(input())
ret = int(math.ceil(x / 5))
print(ret)


n = int(input())
celoe = n // 5
ostatok = n % 5
if ostatok <= 5 and ostatok > 0:
	ostatok = 1
print(celoe + ostatok)


length = int(input())
counter = 0
if length // 5 != 0:
	counter += length // 5
	length %= 5
if length // 4 != 0:
	counter += length // 4
	length %= 4
if length // 3 != 0:
	counter += length // 3
	length %= 3
if length // 2 != 0:
	counter += length // 2
	length %= 2
if length == 1:
	counter += 1
print(counter)


n = int(input())
if n < 6:
	print(1)
elif n % 10 == 0 or n % 5 == 0:
	print(int(n / 5))
else:
	print(int(n / 5) + 1)


def slon(n):
	ile_pi = 0
	ile_pi += n // 5
	n -= ile_pi * 5
	cz = n // 4
	n -= cz * 4
	trz = n // 3
	n -= trz * 3
	dw = n // 2
	n -= dw * 2
	one = n // 1
	n -= one * 1
	wy = ile_pi + cz + trz + dw + one
	print(wy)
n = int(input())
slon(n)


def div(n, num, count):
	steps = int(n / num)
	count += steps
	n = n - steps * num
	return (n, count)
n = int(input())
count = 0
for num in range(5, 0, -1):
	(n, count) = div(n, num, count)
	if n == 0:
		break
print(count)


def solve():
	n = int(input())
	ans = 0
	remainder = n
	for i in range(5, 0, -1):
		if remainder >= i:
			if remainder == 0:
				break
			ans += int(remainder / i)
			remainder = remainder % i
	print(int(ans))
solve()


a = int(input())
count = 0
count += a // 5
if a % 5 == 0:
	print(count)
else:
	print(count + 1)


xStr = input()
x = int(xStr)
step = 0
step = step + x // 5
x = x % 5
step = step + x // 4
x = x % 4
step = step + x // 3
x = x % 3
step = step + x // 2
x = x % 2
step = step + x
print(step)


x = int(input())
dem = 0
while x > 5:
	dem += 1
	x -= 5
print(dem + 1)


from collections import defaultdict as dd
import sys
input = sys.stdin.readline
n = int(input())
cou = 0
for i in range(5, 0, -1):
	if n >= i:
		cou += n // i
	n = -n % i
	if n == 0:
		break
print(cou)


n = int(input())
x = [1, 2, 3, 4, 5]
i = n % 5
k = n // 5
lst = []
if n % 5 == 0:
	for t in range(k):
		lst.append('0')
	print(len(lst))
else:
	for j in range(len(x)):
		if i == x[j]:
			lst.append(i)
			print(len(lst) + k)


n = int(input())
i = m = 1
while i:
	m = 5 * i
	if n <= m:
		print(i)
		break
	i = i + 1


x = int(input())
m = 5
s = 0
while x != 0:
	if x - m >= 0:
		x -= m
		s += 1
	else:
		m -= 1
print(s)


lol = int(input())
print(lol // 5 + (lol % 5 > 0))


n = int(input())
total = n // 5
rem = n % 5
total += rem // 4
rem = rem % 4
total += rem // 3
rem = rem % 3
total += rem // 2
rem = rem % 2
total += rem // 1
rem = rem % 1
print(total)


t = int(input())
k = 0
while t:
	if t < 5:
		if t == 1:
			k = k + 1
			t = t - 1
		elif t == 2:
			k = k + 1
			t = t - 2
		elif t == 3:
			k = k + 1
			t = t - 3
		elif t == 4:
			k = k + 1
			t = t - 4
	elif t >= 5:
		k = k + 1
		t = t - 5
print(k)


num = int(input())
count = 0
while num != 0:
	if num >= 5:
		num = num - 5
		count = count + 1
	else:
		tot = 5 - num
		tot = 5 - tot
		num = num - tot
		count = count + 1
print(count)


x = int(input())
counter = 0
i = 5
while i > 0 and x > 0:
	if x >= i:
		x -= i
		counter += 1
	else:
		i -= 1
print(counter)


n = int(input())
a = [5, 4, 3, 2, 1]
i = 0
counter = 0
for i in range(0, 5):
	if n >= a[i]:
		counter += int(n / a[i])
		n = n % a[i]
print(counter)


import sys
local_launch = False
try:
	open('LOCAL').read()
	local_launch = True
except:
	pass
input_data = open('INPUT.txt').read() if local_launch else sys.stdin.read()
done = {'i': 0}
tokens = input_data.split()

def next_token():
	result = tokens[done['i']]
	done['i'] += 1
	return result

def next_int():
	return int(next_token())

def next_str():
	return next_token()

def sum(a):
	z = 0
	for i in range(len(a)):
		z = z + a[i]
	return z

def max(a):
	maz = a[0]
	for i in range(len(a)):
		if maz < a[i]:
			maz = a[i]
	return maz

def min(a):
	mix = a[0]
	for i in range(len(a)):
		if mix > a[i]:
			mix = a[i]
	return mix

def argmax(a):
	id = 0
	maz = a[0]
	for i in range(len(a)):
		if maz < a[i]:
			maz = a[i]
			id = i
	return id

def argmin(a):
	id = 0
	mix = a[0]
	for i in range(len(a)):
		if mix > a[i]:
			mix = a[i]
			id = i
	return id

def argmax_last(a):
	id = 0
	maz = a[0]
	for i in range(len(a)):
		if maz <= a[i]:
			maz = a[i]
			id = i
	return id

def argmin_last(a):
	id = 0
	mix = a[0]
	for i in range(len(a)):
		if mix >= a[i]:
			mix = a[i]
			id = i
	return id
x = next_int()
print(x // 5 + (x % 5 != 0))


def Main():
	x = int(input())
	steps = x // 5
	if x % 5 > 0:
		steps += 1
	print(steps)
Main()


import math
coordinate = int(input())
step1 = math.floor(coordinate / 5)
if coordinate % 5 == 0:
	step1 = coordinate / 5
	print(int(step1))
else:
	step1 = math.floor(coordinate / 5)
	print(step1 + 1)


n = int(input())

def elep(x):
	if x % 5 == 0:
		a = x // 5
	else:
		a = x // 5 + 1
	return a
s = int(elep(n))
print(s)


def main(x):
	ans = 0
	for i in range(5, 0, -1):
		ans += x // i
		x %= i
	return ans
x = int(input())
print(main(x))


jarak = int(input())
total = 0
hasil = 0
k = 5
while k <= jarak:
	jarak -= k
	total += 1
	if jarak == 1:
		jarak -= 1
		total += 1
	elif jarak == 2:
		jarak -= 2
		total += 1
	elif jarak == 3:
		jarak -= 3
		total += 1
	elif jarak == 4:
		jarak -= 4
		total += 1
if k > jarak:
	if jarak == 1:
		jarak -= 1
		total += 1
	elif jarak == 2:
		jarak -= 2
		total += 1
	elif jarak == 3:
		jarak -= 3
		total += 1
	elif jarak == 4:
		jarak -= 4
		total += 1
print(total)


x = int(input())
if x % 5 == 0:
	min_step = x // 5
else:
	min_step = x // 5 + 1
print(min_step)


n = int(input())
i = 5
step_cnt = 0
while n != 0:
	step_cnt += n // i
	n = n % i
	i -= 1
print(step_cnt)


num = input()
div = int(num) / 5
div = int(div)
rem = int(num) % 5
if rem != 0:
	print(div + 1)
else:
	print(div)


n = int(input())
count = 0
while n > 0:
	if n >= 5:
		p = n // 5
		count += p
		n = n % 5
	elif n >= 4:
		r = n // 4
		count += r
		n = n % 4
	elif n >= 3:
		s = n // 3
		count += s
		n = n % 3
	elif n >= 2:
		t = n // 2
		count += t
		n = n % 2
	elif n == 1:
		s = n // 1
		count += s
		n = n % 1
print(count)


n = input()
n = int(n)
k = 0
while int(n) - 5 >= 0:
	n -= 5
	k += 1
for x in range(1, 5):
	if n - x == 0:
		n = n - x
		k += 1
print(k)


n = int(input())
if n >= 5:
	q = n // 5
	n = n % 5
else:
	print('1')
	quit()
if n:
	q = q + 1
print(q)


n = int(input())
sum = 0
if n == 1:
	print(n)
elif n % 5 == 0:
	sum = n / 5
	print(int(sum))
else:
	rem = n % 5
	sum = n / 5
	if rem == 4:
		print(int(rem / 4 + sum))
	elif rem == 3:
		print(int(rem / 3 + sum))
	elif rem == 2:
		print(int(rem / 2 + sum))
	else:
		print(int(rem / 1 + sum))


x = int(input())
ep = 0
lst = [1, 2, 3, 4, 5]
count = 0
while ep != x:
	if x in lst:
		count = 1
		break
	else:
		ep += max(lst)
		count += 1
		if x - ep in lst:
			count += 1
			ep += x - ep
print(count)


def solve(n):
	cur = 0
	steps = 0
	arr = [5, 4, 3, 2, 1]
	while cur < n:
		for j in range(5):
			if n - cur >= arr[j]:
				steps += 1
				cur += arr[j]
				break
	print(steps)

def run():
	n = int(input())
	solve(n)
run()


import math
num = int(input())
print(str(math.ceil(num / 5)))


x = int(input())
count = 0
remainder = 0
if x <= 5:
	print(1)
elif x > 5:
	count += int(x / 5)
	remainder = x % 5
	if remainder == 0:
		print(count)
	else:
		print(count + 1)


from math import *
remaining_distance = int(input())
steps = remaining_distance / 5
if steps > floor(steps):
	steps = floor(steps) + 1
print(int(steps))


n = int(input())
count = 0
cur = 0
while n - cur > 5:
	count += 1
	cur += 5
print(count + 1)


n = int(input())
if n / 5 == n // 5:
	print(n // 5)
elif n / 5 > n // 5:
	print(n // 5 + 1)


x = int(input())
(d, m) = divmod(x, 5)
n = d + int(m != 0)
print(n)


x = int(input())
steps = 0
ele = 0
while True:
	if ele + 5 <= x:
		ele = ele + 5
		steps = steps + 1
	elif ele + 4 <= x:
		ele = ele + 4
		steps = steps + 1
	elif ele + 3 <= x:
		ele = ele + 3
		steps = steps + 1
	elif ele + 2 <= x:
		ele = ele + 2
		steps = steps + 1
	else:
		ele = ele + 1
		steps = steps + 1
	if ele == x:
		break
	else:
		continue
print(steps)


n = int(input())
ans = 0
for st in range(5, 0, -1):
	if st <= n and n > 0:
		ans += n // st
		n -= st * (n // st)
print(ans)


pathL = int(input())
stepN = int()

def stepCount(pathLenght):
	if pathLenght >= 5:
		return 5
	elif pathLenght >= 4:
		return 4
	elif pathLenght >= 3:
		return 3
	elif pathLenght >= 2:
		return 2
	elif pathLenght >= 1:
		return 1
	else:
		return 0
while pathL > 0:
	stepNumber = stepCount(pathL)
	pathL -= stepNumber
	stepN += 1
print(stepN)


import sys
lines = int(sys.stdin.readlines()[0].strip())
if lines % 5 == 0:
	answer = lines // 5
else:
	answer = lines // 5 + 1
print(answer)


import sys
from random import choice, randint
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

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

def LI():
	return list(map(int, sys.stdin.readline().strip().split()))

def LLI():
	return [list(map(int, l.split())) for l in sys.stdin.readlines().strip()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().strip().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().strip().split()]

def LS():
	return sys.stdin.readline().strip().split()

def I():
	return int(sys.stdin.readline().strip())

def F():
	return float(sys.stdin.readline().strip())

def S():
	return sys.stdin.readline().strip()

def pf(s):
	return print(s, flush=True)

def pe(s):
	return print(str(s), file=sys.stderr)

def JA(a, sep):
	return sep.join(map(str, a))

def JAA(a, s, t):
	return s.join((t.join(map(str, b)) for b in a))
inp = sys.stdin.readline
out = sys.stdout.write

def main():
	x = I()
	c = x // 5
	x = x % 5
	c += x // 4
	x = x % 4
	c += x // 3
	x = x % 3
	c += x // 2
	x = x % 2
	c += x // 1
	x = x % 1
	pf(c)
main()


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

def solver(n):
	return (n - 1) // 5 + 1
main()


n = int(input())
steps = 0
while n != 0:
	if n // 5 >= 1:
		n = n - 5
		steps += 1
	elif n // 4 >= 1:
		n = n - 4
		steps += 1
	elif n // 3 >= 1:
		n = n - 3
		steps += 1
	elif n // 2 >= 1:
		n = n - 2
		steps += 1
	elif n // 1 >= 1:
		n = n - 1
		steps += 1
	else:
		break
print(steps)


import math
a = int(input())
ans = math.ceil(a / 5)
print(ans)


x = int(input())
i = 0
digits = len(str(x))
lastDigit = x % 10

def ichecker(i):
	if i == 4 or i == 3 or i == 2 or (i == 1):
		print(round(1 + x / 5))
	else:
		print(round(i + x / 5))
while True:
	if digits > 1:
		if x % 5 != 0:
			x -= 1
			i += 1
		else:
			ichecker(i)
			break
	elif x % 5 != 0:
		x -= 1
		lastDigit = x % 10
		i += 1
	else:
		ichecker(i)
		break


d = int(input())
covered = 0
while d != 0:
	if d <= 5:
		covered += 1
		print(covered)
		break
	else:
		covered += d // 5
		d = d % 5
else:
	print(covered)


def elephant(x):
	step = 0
	while x >= 5:
		step += 1
		x -= 5
	if x > 0:
		return step + 1
	return step
print(elephant(int(input())))


n = int(input())
if n % 5 == 0:
	print(int(n / 5))
elif n % 5 >= 1 and n % 5 <= 5:
	print(int(n / 5) + 1)


x = int(input())
h = 0
steps = 1
while True:
	h += 1
	if h % 5 == 0 and h < x:
		steps += 1
	elif h == x:
		print(steps)
		break


def main():
	f = int(input())
	print(f // 5 + (0 if f % 5 == 0 else 1), end='')
main()


a = int(input())
res = 0
for t in range(5, 0, -1):
	t1 = a // t
	a -= t * t1
	res += t1
print(res)


k = int(input())
print(k // 5 + int(k % 5 > 0))


x = int(input())
total = 0
while x >= 5:
	full_steps = x // 5
	total += full_steps
	x = x - full_steps * 5
if x == 0:
	print(total)
else:
	print(total + 1)


n = int(input())
i = 0
ans = n // 5
if n % 5 > 0:
	ans += 1
print(ans)


import math
n = int(input())
ans = math.ceil(n / 5.0)
print(ans)


number = int(input())
steplength = [5, 4, 3, 2, 1]
sln = 0
count = 0
while sln <= 4:
	if number - steplength[sln] >= 0:
		number -= steplength[sln]
		count += 1
	else:
		sln += 1
print(count)


x = int(input())
S = 0
S += x // 5
x %= 5
if x != 0:
	S += 1
print(S)


(x, c, v) = (int(input()), 0, 0)
for i in range(0, x, 5):
	c += 1
	v += 5
for i in range(v, x, 4):
	c += 1
	v += 4
for i in range(v, x, 3):
	c += 1
	v += 3
for i in range(v, x, 2):
	c += 1
	v += 2
for i in range(v, x, 1):
	c += 1
	v += 1
print(c)


distance = int(input())
a5 = distance // 5
distance = distance - a5 * 5
a4 = distance // 4
distance = distance - a4 * 4
a3 = distance // 3
distance = distance - a3 * 3
a2 = distance // 2
distance = distance - a2 * 2
t = a5 + a4 + a3 + a2 + distance
print(t)


x = int(input())
count = 0
steps = [5, 4, 3, 2, 1]
for step in steps:
	count += x // step
	x %= step
	if x == 0:
		break
print(count)


num = int(input())
sum = 1
while num > 5:
	num -= 5
	sum += 1
print(sum)


from math import ceil
T = int(input())
R = ceil(T / 5.0)
print(R)


x = int(input())
pasos = [5, 4, 3, 2, 1]
n = 0
p = 0
while x != 0:
	a = x // pasos[n]
	x = x - a * pasos[n]
	p = p + a
	n = n + 1
print(p)


c = int(input())
if c % 5 == 0:
	print(str(int(c / 5)))
else:
	print(str(int(c / 5 + 1)))


input_s = int(input())
mount = input_s // 5
if input_s % 5 > 0:
	print(mount + 1)
else:
	print(mount)


def bublesort(a):
	n = len(a)
	fl1 = False
	while not fl1:
		fl1 = True
		for i in range(n - 1):
			if a[i] > a[i + 1]:
				(a[i], a[i + 1]) = (a[i + 1], a[i])
				fl1 = False

def isgood(a):
	k = 0
	for x in a:
		if x == 'a':
			k += 1
	return k > len(a) // 2

def dell(a):
	k = 0
	for x in a:
		if x != 'a':
			return a[:k] + a[k + 1:]
		k += 1

def pl2d(a):
	for t in a:
		for x in t:
			print(x, end=' ')
		print()

def foundm(x, a, row, col):
	for i in range(row):
		for j in range(col):
			if a[i][j] == x:
				return (i, j)

def swaprow(a, n1, n2):
	(a[n1], a[n2]) = (a[n2], a[n1])

def swapcol(a, k1, k2):
	for lst in a:
		swaprow(lst, k1, k2)
x = int(input())
k = 0
while x >= 5:
	x -= 5
	k += 1
if x != 0:
	k += 1
print(k)


n = int(input())
res = 0
steps = [5, 4, 3, 2, 1]
for s in steps:
	res += n // s
	n -= s * (n // s)
	if n <= 0:
		break
print(res)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 10
mod = 10 ** 9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	n = I()
	return (n + 4) // 5
print(main())


t = int(input())
if t <= 5:
	print(1)
else:
	r = t / 5
	s = t // 5
	if r > int(r):
		s += 1
	print(s)


n = int(input())
a = [1, 2, 3, 4, 5]
s = 0
for x in range(1, 6):
	if n // a[-x] > 0:
		s = s + n // a[-x]
		n = n % a[-x]
print(s)


n = int(input())
num = int(0)
num += int(n / 5)
n -= 5 * int(n / 5)
num += int(n / 4)
n -= 4 * int(n / 4)
num += int(n / 3)
n -= 3 * int(n / 3)
num += int(n / 2)
n -= 2 * int(n / 2)
num += int(n)
print(num)


a = int(input())
step5 = a // 5
remain = a - step5 * 5
if remain == 0:
	print(step5)
else:
	print(step5 + 1)


distance = int(input())
steps = 0
if distance // 5 != 0:
	b = distance // 5
	steps = steps + b
	distance = distance - b * 5
if distance // 4 != 0:
	b = distance // 4
	steps = steps + b
	distance = distance - b * 4
if distance // 3 != 0:
	b = distance // 3
	steps = steps + b
	distance = distance - b * 3
if distance // 2 != 0:
	b = distance // 2
	steps = steps + b
	distance = distance - b * 2
if distance // 1 != 0:
	b = distance // 1
	steps = steps + b
	distance = distance - b * 1
print(steps)


n = int(input())
count = 0
for x in [5, 4, 3, 2, 1]:
	count += n // x
	n = n % x
print(count)


coords = int(input())
if coords % 5 == 0:
	min = int(coords / 5)
else:
	min = int(coords / 5 + 1)
print(min)


x = int(input())
p = x / 5.0
q = x // 5
if p > q:
	print(q + 1)
else:
	print(q)


x = int(input())
e = 0
steps = 0
while e < x:
	while e + 5 <= x:
		steps += 1
		e += 5
	if e != x:
		e = e + (x - e)
		steps += 1
print(steps)


s = int(input())
if s <= 5:
	print(1)
else:
	ost = s // 5
	ost2 = s % 5
	if ost2 > 0:
		print(ost + 1)
	else:
		print(ost)


import math
distance = int(input())
steps = 0
steps_needed = distance / 1
steps = steps_needed
steps_needed = distance / 2
if steps_needed < steps:
	steps = steps_needed
steps_needed = distance / 3
if steps_needed < steps:
	steps = steps_needed
steps_needed = distance / 4
if steps_needed < steps:
	steps = steps_needed
steps_needed = distance / 5
if steps_needed < steps:
	steps = steps_needed
print(int(math.ceil(steps)))


import math
distance = float(input())
print(math.ceil(distance / 5))


elephant = 0
friend = int(input())
if friend >= 5:
	quotient = friend // 5
	remainder = friend % 5
	if remainder == 0:
		print(quotient)
	else:
		print(quotient + 1)
else:
	print(1)


from sys import stdin
N = int(stdin.readline())
mins = 0
mins += N // 5 + 1
if N % 5 == 0:
	mins -= 1
print(mins)


r = int(input())
if r < 6:
	print(1)
else:
	count = 1
	while r > 5:
		count += 1
		r -= 5
	print(count)


n = int(input())
k = -n // 5
print(-k)


n = int(input())
count = 0
for i in range(1, 6)[::-1]:
	x = n // i
	y = n % i
	n = y
	count += x
print(count)


x = int(input())
koraci = x // 5
if x % 5 > 0:
	koraci = koraci + 1
print(koraci)


import math
a = int(input())
arr = [1, 2, 3, 4, 5]
if a in arr:
	print(1)
else:
	div = a / 5
	if div == math.floor(a / 5):
		print(int(div))
	else:
		print(int(div + 1))


import time
import collections

class Time_test:

	def __enter__(self):
		self.enter_time = time.time()

	def __exit__(self, exc_type, exc_val, exc_tb):
		print('Command was executed in', time.time() - self.enter_time)
n = int(input())
acc = n // 5
n %= 5
acc += n // 4
n %= 4
acc += n // 3
n %= 3
acc += n // 2
n %= 2
print(acc + n)


import math
x = int(input())
t1 = int(math.floor(x / 5))
left = int(x - t1 * 5)
if left == 0:
	print(t1)
else:
	print(t1 + 1)


def main(n):
	ans = 0
	walk = [5, 4, 3, 2, 1]
	for v in walk:
		tmp = n // v
		ans += tmp
		n -= tmp * v
	return ans
n = int(input())
print(main(n))


a = int(input())
l = [1, 2, 3, 4, 5]
i = len(l) - 1
count = 0
while a > 0:
	rem = a // l[i]
	count += rem
	a = a % l[i]
	i -= 1
print(count)


x = int(input())
i = 5
steps = 0
while x > 0:
	if x >= i:
		z = x // i
		steps += z
		x -= z * i
	i -= 1
print(steps)


n = int(input())
d = n // 5
r = n - d * 5
if r:
	print(d + 1)
else:
	print(d)


(n, counter) = (int(input()), 0)
while n >= 5:
	n -= 5
	counter += 1
if n > 0:
	counter += 1
print(counter)


def minSteps(num):
	count = 0
	i = 5
	while num != 0 and i != 0:
		count += num // i
		num = num % i
		i -= 1
	return count
num = int(input())
print(minSteps(num))


num = int(input())
steps = num // 5
if num % 5 == 0 and steps != 0:
	print(steps)
else:
	print(steps + 1)


inn = int(input())
resto = 0
for a in reversed(range(5)):
	(inn, resto) = (inn % (a + 1), resto + inn // (a + 1))
print(resto)


import math
pos = int(input())
print(math.ceil(pos / 5))


import math

def elephant():
	value = int(input())
	if value % 5 == 0:
		print(math.floor(value / 5))
	else:
		print(math.floor(value / 5) + 1)
elephant()


steps = [5, 4, 3, 2, 1]
n = int(input())
output = 0
for step in steps:
	mayorDivisor = n // step
	if mayorDivisor > 0:
		n = n - step * mayorDivisor
		output += mayorDivisor
print(output)


f = int(input())
e = 0
ans = 0
while f - e != 0:
	ans += 1
	if f - e >= 5:
		e += 5
	else:
		e += f - e
print(ans)


x = int(input())
steps = 0
i = 5
while x > 0 and i > 0:
	if not x // i == 0:
		steps += x // i
		x -= x // i * i
	i -= 1
print(steps)


import sys
input = sys.stdin.readline

def int_array():
	return list(map(int, input().split()))
n = int(input())
if n // 5 != n / 5:
	print(int(n // 5 + 1))
else:
	print(int(n / 5))


inp = int(input())
print(inp // 5 + (0 if inp % 5 == 0 else 1))


x = int(input())
steps = x // 5
x1 = x % 5
steps += x1 // 4
x1 = x1 % 4
steps += x1 // 3
x1 = x1 % 3
steps += x1 // 2
x1 = x1 % 2
steps += x1
print(steps)


dist = int(input())
step = 0
while dist != 0:
	if dist >= 5:
		dist -= 5
		step += 1
	elif dist >= 4:
		dist -= 4
		step += 1
	elif dist >= 3:
		dist -= 3
		step += 1
	elif dist >= 2:
		dist -= 2
		step += 1
	elif dist >= 1:
		dist -= 1
		step += 1
print(step)


i = int(input())
if i <= 5:
	print(1)
elif i % 5 == 0:
	print(i // 5)
else:
	print(i // 5 + 1)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
sys.setrecursionlimit(100000000)
ii = lambda : int(input())
si = lambda : input()
jn = lambda x, l: x.join(map(str, l))
sl = lambda : list(map(str, input().strip()))
mi = lambda : map(int, input().split())
mif = lambda : map(float, input().split())
lii = lambda : list(map(int, input().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
mod = 1000000007
n = ii()
if n > 5:
	print(ceildiv(n, 5))
else:
	print(1)


def elephant(n):
	lis = [5, 4, 3, 2, 1]
	steps = 0
	num = n
	for i in lis:
		if n >= i:
			steps += n // i
			n %= i
		elif lis.count(n) > 0:
			steps += 1
			n = 0
	return steps
n = int(input().strip())
print(elephant(n))


n = int(input())
counter = 0
for i in range(5, 0, -1):
	i_counter = n // i
	counter = counter + i_counter
	n = n - i_counter * i
print(counter)


n = int(input())
i = 5
count = 1
while 1:
	if i >= n:
		print(count)
		break
	i = i + 5
	count += 1


n = int(input())
step = 0
if n <= 5 and n > 0:
	print('1')
else:
	for i in range(5, 0, -1):
		if n >= i:
			step = step + n // i
			n = n % i
	print(step)


x = int(input())
br = 0
br += x // 5
x = x % 5
br += x // 4
x = x % 4
br += x // 3
x = x % 3
br += x // 2
x = x % 2
br += x // 1
x = x % 1
print(br)


y = int(input())
res = 0
a = 5
while res >= 0:
	res += 1
	if a >= y:
		print(res)
		break
	a += 5


n = int(input(''))
print(n % 5 == 0 and n // 5 or n // 5 + 1)


x = int(input())
count = 0
if x <= 5:
	print('1')
else:
	for i in range(1, x):
		if x > 5:
			x = x - 5
			count = count + 1
	print(count + 1)


n = int(input())
shfi = n // 5
shfo = n % 5 // 4
shth = n % 5 % 4 // 3
shtw = n % 5 % 4 % 3 // 2
sho = n % 5 % 4 % 3 % 2 // 1
n = sho + shtw + shth + shfo + shfi
print(n)


n = int(input())
steps = 1
while n > 5:
	steps += 1
	n -= 5
print(steps)


(f, ans, steps) = (int(input()), 0, 5)
while f and steps >= 1:
	ans += f // steps
	f -= f // steps * steps
	steps -= 1
print(ans)


n = int(input())
temp = n // 5
remaining = n % 5
if n % 5 == 0:
	print(temp)
else:
	print(temp + 1)


def pdiv(num, n=5):
	a = num // n
	if num % n == 0:
		return a
	else:
		return a + 1
a = int(input())
print(pdiv(a))


x = int(input())
i = 5
res = 0
while i > 0:
	res += x // i
	x = x % i
	i -= 1
print(res)


def countStep(n):
	if n % 5 == 0:
		return int(n / 5)
	else:
		return int(n / 5) + 1
n = int(input())
print(countStep(n))


coordX = int(input())
print(int(coordX / 5) + int(bool(coordX % 5)))


import sys
n = int(sys.stdin.readlines()[0])
vals = range(1, 6)
k = 0
for i in range(1, 6):
	if n > 0:
		k += (n - n % vals[-i]) / vals[-i]
		n -= n - n % vals[-i]
sys.stdout.write(str(int(k)))


s = int(input())
res = 0
for x in [5, 4, 3, 2, 1]:
	res += s // x
	s = s % x
print(res)


n = int(input())
step = 0
i = 5
while i > 0:
	step += n // i
	n = n % i
	i -= 1
print(step)


n = int(input())
r = n % 5
q = n // 5
if r != 0 and r < 5:
	print(q + 1)
else:
	print(q)


x = int(input())
(s1, s2) = (x // 5, x % 5)
if s2 != 0:
	print(s1 + 1)
else:
	print(s1)


import sys
n = int(sys.stdin.readline())
steps = 0
if n >= 5:
	steps += n // 5
	n = n % 5
if n >= 4:
	steps += n // 4
	n = n % 4
if n >= 3:
	steps += n // 3
	n = n % 3
if n >= 2:
	steps += n // 2
	n = n % 2
steps += n
sys.stdout.write(str(steps) + '\n')


current = 0
friend = int(input())
count = 0
while current <= friend:
	if current == friend:
		break
	else:
		count += 1
		if friend - current >= 5:
			current = current + 5
		elif friend - current >= 4:
			current = current + 4
		elif friend - current >= 3:
			current = current + 3
		elif friend - current >= 2:
			current = current + 2
		elif friend - current >= 1:
			current = current + 1
print(count)


n = int(input())
shag = 0
if n >= 5:
	shag += n // 5
	n = n % 5
if n == 4:
	shag += n // 4
	n = n % 4
if n == 3:
	shag += n // 3
	n = n % 3
if n == 2:
	shag += n // 2
	n = n % 2
if n == 1:
	shag += n // 1
	n = n % 1
print(shag)


def Steps():
	X = int(input())
	Step_List = [5, 4, 3, 2, 1]
	cnt = 0
	i = 0
	while X > 0:
		if X - Step_List[i] >= 0:
			cnt += 1
			X -= Step_List[i]
		else:
			i += 1
	print(cnt)
Steps()


n = int(input())
c = 0
while n:
	if n >= 5:
		c += n // 5
		n = n % 5
	if n >= 4:
		c += n // 4
		n = n % 4
	if n >= 3:
		c += n // 3
		n = n % 3
	if n >= 2:
		c += n // 2
		n = n % 2
	if n > 0:
		c += n
		n = 0
print(c)


x = int(input())
s = int(x / 5)
if x % 5:
	s += 1
print(s)


house = int(input())
(steps, extra) = divmod(house, 5)
if extra:
	steps += 1
print(steps)


dist = int(input())
if dist % 5 == 0:
	steps = dist // 5
else:
	steps = dist // 5 + 1
print(steps)


t = int(input())
sum = 0
sum += t // 5
if t % 5 > 0 and t % 5 <= 5:
	sum += 1
print(sum)


n = int(input())
if n % 5 != 0:
	n += 5 - n % 5
print(n // 5)


import sys
import math
import re
import io

def main():
	n = int(input())
	ans = int(math.ceil(n / 5))
	print(ans)
main()


def my_input():
	return int(input())

def min_steps(x):
	a = [5, 4, 3, 2, 1]
	kol = i = 0
	while x != 0:
		kol += x // a[i]
		x %= a[i]
		i += 1
	return kol

def main():
	x = my_input()
	print(min_steps(x))
main()


import math
n = int(input())
print(str(int(math.ceil(n / 5))))


x = int(input())
if x > 5:
	st = x // 5
	if x % 5 > 0:
		st += 1
	print(st)
else:
	st = 1
	print(st)


a_number = int(input())
fives = a_number // 5
a_number = a_number % 5
fours = a_number // 4
a_number = a_number % 4
threes = a_number // 3
a_number = a_number % 3
twos = a_number // 2
a_number = a_number % 2
steps = fives + fours + threes + twos + a_number
print(steps)


from math import *

def main():
	n = int(input())
	m = 5
	ans = 0
	while n > 0:
		ans += floor(n / m)
		n = n % m
		m -= 1
	print(ans)
main()


def main():
	x = int(input())
	k = x // 5
	if x % 5 == 0:
		pass
	else:
		k += 1
	print(k)
main()


n = int(input())
steps = [i + 1 for i in range(5)]
steps.sort(reverse=True)
total = 0
for step in steps:
	left = n % step
	total += int((n - left) / step)
	n = left
print(total)


def findNoOfNotes(distance):
	maxSteps = [5, 4, 3, 2, 1]
	numOfSteps = 0
	idx = 0
	while distance > 0 and idx < 6:
		step = maxSteps[idx]
		if step <= distance:
			numOfSteps += distance // step
			distance = distance % step
		idx += 1
	return numOfSteps
stepCount = findNoOfNotes(int(input()))
print(stepCount)


n = int(input())
step = 5
qst = 0
if n % step == 0:
	qst += n // step
elif n % step > 0:
	qst += n // step + 1
elif n % step < 0:
	qst += 1
print(qst)


distance = int(input())
remainder = distance % 5
remainder = 1 if remainder != 0 else remainder
print(distance // 5 + remainder)


x = int(input(''))
L = [5, 4, 3, 2, 1]
odp = 0
while x != 0:
	for i in range(len(L)):
		if x >= L[i]:
			odp += x // L[i]
			x = x % L[i]
		if x == 0:
			break
print(odp)


friendHouseX = int(input())
minimumAmountOfSteps = int(friendHouseX / 5)
if friendHouseX % 5 != 0:
	minimumAmountOfSteps += 1
print(minimumAmountOfSteps)


import sys
import math
s = int(input())
minimum = 0
while s > 0:
	if s >= 5:
		minimum += s / 5
		s = s % 5
	elif s == 4:
		s -= 4
		minimum += 1
		break
	elif s == 3:
		s -= 3
		minimum += 1
		break
	elif s == 2:
		s -= 2
		minimum += 1
		break
	elif s == 1:
		s -= 1
		minimum += 1
		break
	else:
		break
print(int(minimum))


x = int(input())
T = x // 5
if x % 5 == 0:
	R = T
else:
	R = T + 1
print(R)


x = int(input(''))
i = 5
output = 0
while i >= 1:
	h = x // i
	x = x % i
	output = output + h
	i -= 1
print(output)


x = int(input())
(d, r) = divmod(x, 5)
print(d + bool(r))


position = list(range(1, 6))
x = int(input())
if x in position:
	print(1)
else:
	if x % 5 == 0:
		print(int(x / 5))
		exit()
	print(1 + int(x / 5))


import math
x = int(input())
steps = 0
fives = 0
fours = 0
threes = 0
twos = 0
ones = 0
fives = math.floor(x / 5)
x = x - fives * 5
fours = math.floor(x / 4)
x = x - fours * 4
threes = math.floor(x / 3)
x = x - threes * 3
twos = math.floor(x / 2)
x = x - twos * 2
ones = math.floor(x / 1)
x = x - ones * 1
steps = fives + fours + threes + twos + ones
print(steps)


n = int(input())
print(n // 5 + int(n % 5 / 5 + 0.99))


def elephant_step(dist):
	steps = [5, 4, 3, 2, 1]
	count = 0
	if dist in steps:
		return 1
	else:
		for step in steps:
			while dist >= step:
				dist = dist - step
				count += 1
		return count
dist = int(input())
print(elephant_step(dist))


x = int(input())
num = 0
if x >= 5:
	a1 = x // 5
	num += a1
	b1 = x % 5
	if b1 != 0:
		num += 1
	else:
		num += 0
	print(num)
else:
	print('1')


n = int(input())
cmp = 0
for i in range(0, n, 5):
	cmp += 1
print(cmp)


s = int(input())
a = [5, 4, 3, 2, 1]
pas = 0
for i in range(s):
	for j in range(5):
		if s - a[j] >= 0:
			s = s - a[j]
			pas += 1
			break
	if s == 0:
		print(pas)
		exit()


ending_position = int(input())
possible_moves = [5, 4, 3, 2, 1]

def find_answer(ending_position, possible_moves):
	moves_needed = 0
	for current_move in possible_moves:
		while ending_position >= current_move:
			ending_position -= current_move
			moves_needed += 1
	print(moves_needed)
find_answer(ending_position, possible_moves)


x = int(input())
count = 0
t = 5
while t > 0:
	ss = int(x / t)
	count += ss
	df = x % t
	t -= 1
	if df != 0:
		x = df
	else:
		break
print(count)


d = int(input())
steps = 0
while d > 5:
	d -= 5
	steps += 1
if d <= 5:
	steps += 1
print(steps)


n = int(input().strip(' '))
div = [5, 4, 3, 2, 1]
i = 0
cont = 0
while n > 0:
	if n >= div[i]:
		n -= div[i]
		cont += 1
	else:
		i += 1
print(cont)


sum = 0
n = int(input())
k = n // 5
sum = sum + k
n = n % 5
k = n // 4
sum = sum + k
n = n % 4
k = n // 3
sum = sum + k
n = n % 3
k = n // 2
sum = sum + k
n = n % 2
k = n // 1
sum = sum + k
n = n % 1
print(sum)


n = int(input())
if n > 5:
	c = n // 5
	if n % 5 == 4 or n % 5 == 3 or n % 5 == 2 or (n % 5 == 1):
		print(c + 1)
	else:
		print(c)
elif n == 5 or n == 4 or n == 3 or (n == 2) or (n == 1):
	print(1)


try:
	x = int(input())
	p = 0
	cnt = 0
	while p != x:
		if p + 5 <= x:
			p = p + 5
		elif p + 4 <= x:
			p = p + 4
		elif p + 3 <= x:
			p = p + 3
		elif p + 2 <= x:
			p = p + 2
		elif p + 1 <= x:
			p = p + 1
		cnt += 1
	print(cnt)
except:
	pass


x = int(input())
add = 0
n = x // 5
add = add + n
x = x - 5 * n
n = x // 4
add = add + n
x = x - 4 * n
n = x // 3
add = add + n
x = x - 3 * n
n = x // 2
add = add + n
x = x - 2 * n
n = x // 1
add = add + n
x = x - 1 * n
print(add)


def A617():
	k = int(input())
	if k % 5 == 0:
		print(int(k / 5))
	else:
		print(int(k / 5) + 1)
A617()


a = int(input())
y = 0
while a != 0:
	while a >= 5:
		y += 1
		a = a - 5
	while a >= 4:
		y += 1
		a = a - 4
	while a >= 3:
		y += 1
		a = a - 3
	while a >= 2:
		y += 1
		a = a - 2
	while a >= 1:
		y += 1
		a = a - 1
print(y)


distance = int(input())
n = distance % 5
if n != 0:
	steps = distance // 5 + 1
else:
	steps = distance // 5
print(steps)


try:
	x = int(input())
	b = 0
	count = 0
	while x > b:
		b += 5
		count += 1
	print(count)
except:
	pass


def ll():
	return int(input())
s = ll()
l = [5, 4, 3, 2, 1]
x = 0
for i in l:
	x += s // i
	s = s % i
print(x)


def min_steps(dist):
	steps = 0
	for i in range(5, 0, -1):
		steps += dist // i
		dist -= dist // i * i
	return steps
x = int(input())
print(min_steps(x))


n = int(input())
count = 0
if n >= 5:
	count += n // 5
	n = n % 5
if n >= 4:
	count += n // 4
	n = n % 4
if n >= 3:
	count += n // 3
	n = n % 3
if n >= 2:
	count += n // 2
	n = n % 2
count += n
print(count)


n = int(input())
s = (5, 4, 3, 2, 1)

def solve(n):
	c = 0
	while n > 0:
		for i in s:
			if n >= i:
				c += 1
				n -= i
				break
	return c
print(solve(n))


from sys import stdin, stdout
x2 = int(stdin.readline().rstrip())
ans = 0
n = 5
if x2 >= n:
	(x2, ans) = (int(x2 % n), ans + int(x2 / n))
n = 4
if x2 >= n:
	(x2, ans) = (int(x2 % n), ans + int(x2 / n))
n = 3
if x2 >= n:
	(x2, ans) = (int(x2 % n), ans + int(x2 / n))
n = 2
if x2 >= n:
	(x2, ans) = (int(x2 % n), ans + int(x2 / n))
n = 1
if x2 >= n:
	(x2, ans) = (int(x2 % n), ans + int(x2 / n))
stdout.write(str(ans) + '\n')


a = int(input())
p = 1
while a > 5:
	p += 1
	a -= 5
print(p)


inp = int(input())
count = 0
if inp > 5:
	main = inp // 5
	if inp % 5 == 0:
		print(main)
	else:
		print(main + 1)
else:
	print('1')


d = int(input())
v = '54321'
s = 0
for i in v:
	s += d // int(i)
	d = d % int(i)
print(s)


a = int(input())
list = [5, 4, 3, 2, 1]
count = 0
while 1:
	if a == 0:
		break
	for i in list:
		if i <= a:
			if a == 0:
				break
			a = a - i
			count += 1
			break
print(count)


m = int(input())
r = [5, 4, 3, 2, 1]
i = 0
count = 0
while m != 0:
	count += m // r[i]
	m %= r[i]
	i += 1
print(count)


n = int(input())
actuel = n
etape = 0
while actuel != 0:
	if actuel >= 5:
		etape += actuel // 5
		actuel %= 5
	elif actuel >= 4:
		etape += actuel // 4
		actuel %= 4
	elif actuel >= 3:
		etape += actuel // 3
		actuel %= 3
	elif actuel >= 2:
		etape += actuel // 2
		actuel %= 2
	elif actuel >= 1:
		etape += actuel // 1
		actuel %= 1
print(etape)


import sys
x = sys.stdin.readline()
y = x.strip()
e = int(y)
steps = e // 5
if e % 5 != 0:
	steps += 1
print(steps)


schritt = 0
x = int(input())
schritt = schritt + x // 5
x = x - x // 5 * 5
schritt = schritt + x // 4
x = x - x // 4 * 4
schritt = schritt + x // 3
x = x - x // 3 * 3
schritt = schritt + x // 2
x = x - x // 2 * 2
schritt = schritt + x // 1
x = x - x // 1 * 1
print(schritt)


x = int(input())
count = 0
n = 5
while n >= 1:
	a = x // n
	x = x - n * a
	count = count + a
	n = n - 1
print(count)


import sys, itertools, math
x = int(sys.stdin.readline().strip())
print(math.ceil(x / 5))


g = (int(input()) - 1) // 5
q = g + 1
print(q)


n = int(input())
count = 0
while n > 0:
	count += 1
	n -= min(n, 5)
print(count)


point = int(input())
need = 0
if point >= 5:
	need += point // 5
	point = point % 5
if point >= 4:
	need += point // 4
	point = point % 4
if point >= 3:
	need += point // 3
	point = point % 3
if point >= 2:
	need += point // 2
	point = point % 2
elif point >= 1:
	need += point // 1
	point = point % 1
print(need)


p = int(input())
j = 0
j = j + p // 5
p = p % 5
j = j + p // 4
p = p % 4
j = j + p // 3
p = p % 3
j = j + p // 2
p = p % 2
j = j + p // 1
p = p % 1
print(j)


__author__ = 'Utena'
print((int(input()) + 4) // 5)


from math import ceil
x = int(input())
steps = 5
y = ceil(x / steps)
print(y)


n = int(input())
cont = 0
lista = [5, 4, 3, 2, 1]
indice = 0
rest = n
while rest > 0 and indice < len(lista):
	cont += int(rest / lista[indice])
	rest = rest % lista[indice]
	indice += 1
print(cont)


n = int(input())
a = n % 5
aj = int(n / 5)
lst = []
if a == 0:
	print(aj)
else:
	lst.append(aj)
	b = a % 4
	bj = int(a / 4)
	lst.append(bj)
	if b == 0:
		print(sum(lst))
	else:
		c = b % 3
		cj = int(b / 3)
		lst.append(cj)
		if c == 0:
			print(sum(lst))
		else:
			d = c % 2
			dj = int(c / 2)
			lst.append(dj)
			if d == 0:
				print(sum(lst))
			else:
				lst.append(d)
				print(sum(lst))


from sys import stdin
x = int(stdin.readline())
a = x // 5
b = x % 5
if b == 0:
	print(a)
else:
	print(a + 1)


def Elephant(n):
	count = 0
	if n >= 5:
		count = count + n // 5
		n = n % 5
	if n >= 4:
		count = count + n // 4
		n = n % 4
	if n >= 3:
		count = count + n // 3
		n = n % 3
	if n >= 2:
		count = count + n // 2
		n = n % 2
	if n >= 1:
		count = count + n // 1
		n = n % 1
	return count
x = int(input())
print(Elephant(x))


n = int(input())
if n % 5 == 0:
	print(n // 5)
else:
	p = n // 5
	q = n % 5
	if q >= 0 and q <= 4:
		print(p + 1)


n = int(input())
if n <= 5:
	print('1')
else:
	s = 0
	j = 5
	while j > 0:
		m = n // j
		s = s + m
		n = n % j
		j = j - 1
	print(s)


distance = int(input())
total_steps = 0
for i in (5, 4, 3, 2, 1):
	steps = distance // i
	distance = distance % i
	total_steps += steps
	if distance == 0:
		break
print(total_steps)


(x, y) = divmod(int(input()), 5)
if y != 0:
	x += 1
print(x)


n = int(input())
step = [1, 2, 3, 4, 5]
c = 0
while n != 0:
	mx = 0
	for i in step:
		if i > mx and mx < n:
			mx = i
			d = n // mx
	n = n - d * mx
	c = c + d
print(c)


n = int(input())
print(str(n // 5) if n % 5 == 0 else str(n // 5 + 1))


x = int(input())
y = 0
if x > 5:
	if x % 5 != 0:
		y = int(x / 5)
		print(y + 1)
	elif x % 5 == 0:
		y = int(x / 5)
		print(y)
elif x <= 5:
	print(1)


s = int(input())
if s % 5:
	print(s // 5 + 1)
else:
	print(s // 5)


x = int(input())
ans = 0
ans += x // 5
x -= x // 5 * 5
ans += x // 4
x -= x // 4 * 4
ans += x // 3
x -= x // 3 * 3
ans += x // 2
x -= x // 2 * 2
ans += x
print(ans)


a = int(input())
result = a // 5
if a % 5 != 0:
	result += 1
print(result)


n = int(input())
flag = True
count = 0
new = 0
while flag == True:
	new = new + 5
	count += 1
	if new >= n:
		flag = False
print(count)


x = int(input())
count = 0
y = int(x / 5)
count = count + y
x = x - 5 * y
y = int(x / 4)
count = count + y
x = x - 4 * y
y = int(x / 3)
count = count + y
x = x - 3 * y
y = int(x / 2)
count = count + y
x = x - 2 * y
y = int(x / 1)
count = count + y
x = x - y
print(count)


import math
d = int(input())
d = math.ceil(d / 5)
if d == 0:
	print(1)
else:
	print(d)


a = int(input())
if a >= 5:
	if a % 5 != 0:
		res = a // 5 + 1
	else:
		res = a // 5
else:
	res = 1
print(res)


n = int(input())
x = n
k = n % 5
n //= 5
if k == 0:
	k = n
elif n == 0:
	k = 0
else:
	k = n + 1
if x <= 4:
	print(1)
else:
	print(k)


def main():
	x = int(input())
	print((x + 4) // 5)
main()


n = int(input())
if n % 5 == 0:
	mini = int(n / 5)
else:
	mini = int(n / 5) + 1
print(mini)


distance = int(input())
if distance % 5 == 0:
	print(str(distance // 5))
else:
	print(str(distance // 5 + 1))


x = int(input())
v = x % 5
if v == 0 and x >= 5:
	print(x // 5)
else:
	print(x // 5 + 1)


def getLines(num):
	inputLines = []
	for i in range(0, num):
		line = input()
		if line:
			inputLines.append(line)
		else:
			break
	return inputLines

def notZeroPow(num, p):
	return True if num >= 1 and num <= pow(10, p) else False
lines = getLines(1)
result = 0
n = int(lines[0])
arr = [5, 4, 3, 2, 1]
for e in arr:
	r = round(n / e + 0.49)
	if int(r) * e >= n:
		result = int(r)
		break
print(result)


n = int(input())
count = 0
x = n % 5
if n <= 5:
	print('1')
else:
	count = n // 5
	if x % 4 == 0:
		count += x // 4
	elif x % 3 == 0:
		count += x // 3
	elif x % 2 == 0:
		count += x // 2
	elif x % 1 == 0:
		count += x // 1
	print(int(count))


def solution(x):
	k = 5
	counter = 0
	numbers = [5, 4, 3, 2, 1]
	for i in range(len(numbers)):
		counter += int(x / numbers[i])
		x = x % numbers[i]
	return counter
n = int(input())
print(int(solution(n)))


dist = int(input())
steps = 0
n = 5
while n > 0:
	setnum = dist // n
	dist = dist % n
	steps = steps + setnum
	n = n - 1
print(steps)


n = int(input())
nd = 0
while n > 0:
	n = n - 5
	nd += 1
print(nd)


n = int(input())
step = [5, 4, 3, 2, 1]
st = 0
for i in step:
	st = st + int(n / i)
	n = n % i
print(st)


__author__ = 'Admin'
n = int(input())
ans = 0
if n % 5 == 0:
	ans = n // 5
else:
	ans = n // 5 + 1
print(ans)


n = int(input())
res = 0
p = 5
k = n
while True:
	if n <= 5:
		break
	div = n // p
	res += div
	if n - p * div is 0:
		break
	if n - div * p <= 5:
		res += 1
		break
	p -= 1
	n = div
if k <= 5:
	print('1')
else:
	print(res)


a = int(input())
answer = a // 5
if a % 5 != 0:
	answer += 1
print(answer)


def elephant():
	coord = int(input())
	steps_taken = 0
	for steps in range(5, 0, -1):
		if coord / steps >= 1:
			steps_taken = int(coord / steps) + steps_taken
			coord = int(coord % steps)
	print(steps_taken)
	return
elephant()


num = int(input())
c = 1
while num > 5:
	c += 1
	num -= 5
print(c)


friend = int(input())
steps = friend / 5
if friend % 5 != 0:
	steps += 1
print(int(steps))


c = int(input())
steps = 0
if c >= 5:
	steps += c // 5
	c = c % 5
if c >= 4:
	steps += c // 4
	c = c % 4
if c >= 3:
	steps += c // 3
	c = c % 3
if c >= 2:
	steps += c // 2
	c = c % 2
if c >= 1:
	steps += c // 1
	c = c % 1
print(steps)


import math
attalums = int(input())
print(math.ceil(attalums / 5))


n = int(input())
m100 = n // 5
m20 = n % 5 // 4
m10 = n % 5 % 4 // 3
m5 = n % 5 % 4 % 3 // 2
m1 = n % 5 % 4 % 3 % 2 // 1
m = m100 + m20 + m10 + m5 + m1
print(m)


cntr = 0
x = 0
f = int(input())
for i in range(5, 0, -1):
	while x <= f:
		x += i
		if x < f:
			cntr += 1
	if x != i:
		x -= i
	else:
		break
print(cntr + 1)


k = 0
n = int(input())
total = 0
while k < n:
	if k + 5 <= n:
		total = total + 1
		k = k + 5
	elif k + 4 <= n:
		total = total + 1
		k = k + 4
	elif k + 3 <= n:
		total = total + 1
		k = k + 3
	elif k + 2 <= n:
		total = total + 1
		k = k + 2
	elif k + 1 <= n:
		total = total + 1
		k = k + 1
	if k == n:
		print(total)
		break


n = int(input())
arr = [5, 4, 3, 2, 1]
result = 0
for i in range(5):
	result += n // arr[i]
	n = n % arr[i]
print(result)


X = int(input())
Y = X // 5
if X % 5 > 0:
	Y += 1
print(Y)


x = int(input())
count = 0
rem = 0
if x <= 5:
	print(1)
elif x > 5:
	count += int(x / 5)
	rem = x % 5
	if rem == 0:
		print(count)
	else:
		print(count + 1)


n = int(input())
i = 1
c = 0
d = 1
if n % 5 == 0:
	print(n // 5)
else:
	while d <= n:
		d = i * 5
		i = i + 1
		c = c + 1
	print(c)


n = int(input())
z = 0
while n > 5:
	n -= 5
	z += 1
if n != 0:
	z += 1
print(z)


x = input()
step = 0
road = int(x)
while road != 0:
	if road >= 5:
		step = step + int(road / 5)
		road = road % 5
	elif road >= 4:
		road = road - 4
		step += 1
	elif road >= 3:
		road = road - 3
		step += 1
	elif road >= 2:
		road = road - 2
		step += 1
	elif road >= 1:
		road = road - 1
		step += 1
print(step)


x = int(input())
d = 0
c = 0
while x >= 5:
	d += 5
	x -= 5
	c += 1
else:
	if x != 0:
		c += 1
print(c)


def main():
	inp = int(input())
	print(inp // 5 + 1 if inp % 5 != 0 else inp // 5)
main()


ort = int(input(''))
schritte = 0
while ort > 0:
	if ort >= 1:
		if ort >= 2:
			if ort >= 3:
				if ort >= 4:
					if ort >= 5:
						ort -= 5
						schritte += 1
					else:
						ort -= 4
						schritte += 1
				else:
					ort -= 3
					schritte += 1
			else:
				ort -= 2
				schritte += 1
		else:
			ort -= 1
			schritte += 1
print(schritte)


import sys

def main():
	x = int(input())
	num_steps = x // 5
	if x % 5 != 0:
		num_steps += 1
	print(num_steps)
	return 0
sys.exit(main())


DISTANCT = int(input())
STEP = DISTANCT / 5
if STEP != int(STEP):
	STEP += 1
print(int(STEP))


q = int(input())
for i in range(5, 0, -1):
	if q >= i:
		s = (q + 5 - 1) // 5
print(s)


y = int(input())
i = 0
i += y // 5
y = y % 5
i += y // 4
y = y % 4
i += y // 3
y = y % 3
i += y // 2
y = y % 2
i += y // 1
y = y % 1
print(i)


inp = int(input())
ans = 0
if inp in [1, 2, 3, 4, 5]:
	ans = 1
elif inp % 5 == 0:
	ans = inp // 5
else:
	b = 0
	b = inp // 5
	ans = b + 1
print(ans)


x = int(input())
c = 0
while x > 0:
	if x >= 5:
		c += 1
		x -= 5
	elif x >= 4 and x < 5:
		c += 1
		x -= 4
	elif x >= 3 and x < 4:
		c += 1
		x -= 3
	elif x >= 2 and x < 3:
		c += 1
		x -= 2
	elif x >= 1 and x < 2:
		c += 1
		x -= 1
print(c)


import math
n = int(input())
xtra = 0
if n % 5 != 0:
	xtra = 1
totalMoves = math.floor(n / 5) + xtra
print(totalMoves, end='')


x = int(input())
a = [1, 2, 3, 4, 5]
l = list()
for i in a:
	d = x % i
	f = x // i
	if d in a:
		f = f + 1
	l.append(f)
print(min(l))


aantalstappen = int(input())
p = 5
if aantalstappen < 6:
	print('1')
else:
	for i in range(5):
		delen = aantalstappen // p
		overig = aantalstappen % p
		if overig == 0:
			print(delen)
			break
		elif overig < 6:
			print(delen + 1)
			break


import math

class CodeforcesTask617ASolution:

	def __init__(self):
		self.result = ''
		self.x = 0

	def read_input(self):
		self.x = int(input())

	def process_task(self):
		steps = self.x // 5 + math.ceil(self.x % 5 / 5)
		self.result = str(steps)

	def get_result(self):
		return self.result
Solution = CodeforcesTask617ASolution()
Solution.read_input()
Solution.process_task()
print(Solution.get_result())


n = int(input())
l = [1, 2, 3, 4, 5]
v = 0
while n != 0:
	if n >= 5:
		v = n // 5
		n = n % 5
	elif n >= 4:
		v = v + n // 4
		n = n % 4
	elif n >= 3:
		v = v + n // 3
		n = n % 3
	elif n >= 2:
		v = v + n // 2
		n = n % 2
	else:
		v = v + n
		n = 0
print(v)


def main():
	x = int(input())
	print(solve(x))

def solve(x):
	passos = 0
	for d in range(5, 0, -1):
		passos += x // d
		x %= d
	return passos
main()


n = int(input())
m = n % 5
c = n // 5
if m == 0:
	print(c)
else:
	print(c + 1)


n = int(input())
c = 0
step = (5, 4, 3, 2, 1)
while n > 0:
	for i in step:
		if n >= i:
			c += 1
			n -= i
			break
print(c)


from collections import deque
import datetime
import math
import os
import random
import re
import sys

def main():
	n = int(input())
	z = (n + 4) // 5
	print(z)
main()


s = int(input())
step = 0
l = [5, 4, 3, 2, 1]
run = True
while s > 0:
	if s >= 5:
		step += 1
		s -= 5
	elif s >= 4:
		step += 1
		s -= 4
	elif s >= 3:
		step += 1
		s -= 3
	elif s >= 2:
		step += 1
		s -= 2
	elif s >= 1:
		step += 1
		s -= 1
print(step)


x = int(input())
c = 0
done5 = False
while not done5:
	if x // 5 == 0:
		done5 = True
	else:
		c += x // 5
		x -= x // 5 * 5
done4 = False
while not done4:
	if x // 4 == 0:
		done4 = True
	else:
		c += x // 4
		x -= x // 4 * 4
done3 = False
while not done3:
	if x // 3 == 0:
		done3 = True
	else:
		c += x // 3
		x -= x // 3 * 3
done2 = False
while not done2:
	if x // 2 == 0:
		done2 = True
	else:
		c += x // 2
		x -= x // 2 * 2
done1 = False
while not done1:
	if x // 1 == 0:
		done1 = True
	else:
		c += x // 1
		x -= x // 1 * 1
print(c)


a = int(input())
dev = 5
i = 0
while dev != 0:
	if a // dev != 0:
		i = i + a // dev
		a = a % dev
		dev = dev - 1
	else:
		dev = dev - 1
print(i)


import math
user_input = int(input())
print(math.ceil(user_input / 5))


n = int(input())
if n <= 5:
	print('1')
elif (n / 5).is_integer():
	print(int(n / 5))
else:
	k = int(n / 5) + 1
	print(k)


(x,) = map(int, input().split())
print((x - 1) // 5 + 1)


n = int(input())
a = 0
for i in range(5, 0, -1):
	a += n // i
	n %= i
print(a)


x = int(input())
count = 0
while x >= 5:
	x = x - 5
	count += 1
if x < 5 and x > 0:
	count += 1
print(count)


x = int(input())
m = [1, 2, 3, 4, 5]
i = 4
z = 0
while x != 0:
	z += x // m[i]
	x = x % m[i]
	i -= 1
print(z)


n = int(input())
val = 5
x = 0
while n != 0:
	while n >= val:
		n -= val
		x += 1
	val -= 1
print(x)


import sys
a = int(sys.stdin.readline().strip())
b = a // 5
if a % 5 != 0:
	b += 1
print(b)


import math
dis = int(input())
pave = 0
while dis > 0:
	if dis >= 5:
		pave = math.floor(dis / 5)
		dis = dis % 5
	elif dis >= 4:
		pave += 1
		dis = dis % 4
	elif dis >= 3:
		pave += 1
		dis = dis % 3
	elif dis >= 2:
		pave += 1
		dis = dis % 2
	else:
		pave += dis
		dis = 0
print(pave)


n = int(input())
res = 0
for x in range(5, 0, -1):
	res += n // x
	n = n % x
print(res)


import sys
import io

def run(test, res):
	x = io.StringIO()
	with io.StringIO(test) as sys.stdin:
		with x as sys.stdout:
			work()
			z = x.getvalue().strip()
	sys.stdout = sys.__stdout__
	print(z == test)
	print(res)
	print(z)

def work():
	x = int(input())
	c = x // 5
	c += 0 if x % 5 == 0 else 1
	print(c)

def test():
	run('5', '1')
	run('12', '3')
if len(sys.argv) > 1:
	test()
else:
	work()


p = int(input())
c = 1
while p > 5:
	c = c + 1
	p = p - 5
print(c)


def foo(x):
	if x <= 5:
		return 1
	if x % 5 == 0:
		return x / 5
	return 1 + (x - x % 5) / 5
x = int(input())
print(int(foo(x)))


x = int(input())

def steps(x):
	count = x // 5
	count += int(x % 5 != 0)
	return count
print(steps(x))


x = int(input())
cnt = 0
if x > 5:
	n = x // 5
	a = x - n * 5
	cnt = cnt + n
	if a == 4 or a == 3 or a == 2 or (a == 1):
		cnt = cnt + 1
else:
	cnt = cnt + 1
print(cnt)


totalSetps = int(input())
print(totalSetps // 5 + 1 if totalSetps % 5 != 0 else totalSetps // 5)


n = int(input())
res = 1
while n > 5:
	res += 1
	n -= 5
print(res)


x = int(input())
otvet = 0
otvet += x // 5
x = x % 5
otvet += x // 4
x = x % 4
otvet += x // 3
x = x % 3
otvet += x // 2
x = x % 2
otvet += x
print(otvet)


x = int(input())
o = x % 10
if o == 0 or o == 5:
	print(x // 5)
if o == 6 or o == 7 or o == 8 or (o == 9):
	print(x // 5 + 1)
if o == 1 or o == 2 or o == 3 or (o == 4):
	print(x // 5 + 1)


a = int(input())
c = 0
if not a % 5 == 0:
	c = a // 5 + 1
else:
	c = a // 5
print(c)


x = int(input())
out = 0
while x > 0:
	if x >= 5:
		out += 1
		x -= 5
		continue
	if x >= 4:
		out += 1
		x -= 4
		continue
	if x >= 3:
		out += 1
		x -= 3
		continue
	if x >= 2:
		out += 1
		x -= 2
		continue
	if x >= 1:
		out += 1
		x -= 1
		continue
print(out)


x = int(input(''))
0 <= x <= 100000
a = x // 5
b = x % 5
c = b // 4
d = b % 4
e = d // 3
f = d % 3
g = f // 2
h = f % 2
k = a + c + e + g + h
print(k)


x = int(input())
d = 0
e = 0
while True:
	if x >= 5:
		x = x - 5
		d += 1
	elif x == 0:
		break
	else:
		e += 1
		break
print(d + e)


moves = [5, 4, 3, 2, 1]
n = int(input())
n_of_moves = 0
for move in moves:
	if n <= 0:
		break
	n_of_moves += n // move
	n = n % move
print(n_of_moves)