Vasya has a non-negative integer n. He wants to round it to nearest integer, which ends up with 0. If n already ends up with 0, Vasya considers it already rounded.

For example, if n = 4722 answer is 4720. If n = 5 Vasya can round it to 0 or to 10. Both ways are correct.

For given n find out to which integer will Vasya round it.


-----Input-----

The first line contains single integer n (0 ≤ n ≤ 10^9) — number that Vasya has.


-----Output-----

Print result of rounding n. Pay attention that in some cases answer isn't unique. In that case print any correct answer.


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

Output
0

Input
113

Output
110

Input
1000000000

Output
1000000000

Input
5432359

Output
5432360



-----Note-----

In the first example n = 5. Nearest integers, that ends up with zero are 0 and 10. Any of these answers is correct, so you can print 0 or 10.

Difficulty: EASY

Solutions:
n = int(input())
b = n % 10
if b > 5:
	n += 10 - b
else:
	n -= b
print(n)


num = input()
rem = int(num) % 10
if rem <= 5:
	print(int(num) - rem)
elif rem > 5:
	print(int(num) + 10 - rem)
else:
	print(int(num) - rem)


m = int(input())
if m % 10 == 0:
	print(m)
elif m % 10 <= 5:
	print(m - m % 10)
else:
	print(m + (10 - m % 10))


N = int(input())
if N % 10 > 5:
	print(N + (10 - N % 10))
else:
	print(N - N % 10)


n = int(input())
ans = n // 10 * 10
ld = int(str(n)[-1])
if ld in [6, 7, 8, 9]:
	ans += 10
print(ans)


n = input()
if int(n[len(n) - 1]) > 5:
	a = int(n) % 10
	print(int(n) + (10 - a))
else:
	print(n[0:len(n) - 1] + '0')


n = int(input())
(x, left, right, y) = (n, 0, 0, n)
while str(n)[-1] != '0':
	n -= 1
	left += 1
while str(x)[-1] != '0':
	x += 1
	right += 1
if left <= right:
	print(y - left)
else:
	print(y + right)


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


n = int(input())
minus = n % 10
plus = 10 - n % 10
if minus > plus:
	print(n + plus)
else:
	print(n - minus)


print((int(input()) + 4) // 10 * 10)


n = input()
li = list(n)
if len(li) == 1:
	if int(li[-1]) <= 5:
		print(0)
	else:
		print(10)
elif int(li[-1]) <= 5:
	print(int(n) - int(li[-1]))
else:
	print(int(n) + (10 - int(li[-1])))


n = int(input())
if n % 10 <= 5:
	n = str(n)
	print(n[:-1] + '0')
else:
	n = str(n + 10)
	print(n[:-1] + '0')


n = int(input())
k = n
if n == 5:
	print(0)
elif n % 10 == 0:
	print(n)
else:
	a = n % 10
	n = int(n / 10)
	if a < 5:
		print(n * 10)
	elif a > 5:
		q = 10 - a
		print(k + q)
	else:
		print(str(n) + '0')


import math, fractions
s = str(input())
l = len(s) - 1
if int(s[l]) > 5:
	print(int(s) + 10 - int(s[l]))
else:
	print(s[:l] + '0')


i = input
n = int(i())
a = n % 10
if a > 5:
	n += 10 - a
else:
	n -= a
print(n)


a = int(input())
b = a % 10
if b <= 5:
	print(a - b)
else:
	print(a - b + 10)


n = int(input())
mod = n % 10
if mod == 0:
	print(n)
elif mod > 5:
	print(n + 10 - mod)
else:
	print(n - mod)


t = int(input())
if t % 10 == 0:
	print(t)
elif t % 10 > 5:
	print(t + 10 - t % 10)
else:
	print(t - t % 10)


n = int(input())
if n % 10 >= 6:
	print(n + (10 - n % 10))
else:
	print(n // 10 * 10)


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


import math
n = int(input())
t = n % 10
i = n // 10
if t > 5:
	print(i + 1, end='')
	print(0)
elif i == 0:
	print(0)
else:
	print(i, end='')
	print(0)


n = str(input())
if n[len(n) - 1] == '0':
	print(n)
elif n[len(n) - 1] == '5':
	print(int(n) - 5)
else:
	l = []
	l.append(int(n) - 1)
	l.append(int(n) - 2)
	l.append(int(n) - 3)
	l.append(int(n) - 4)
	l.append(int(n) - 5)
	l.append(int(n) + 1)
	l.append(int(n) + 2)
	l.append(int(n) + 3)
	l.append(int(n) + 4)
	l.append(int(n) + 5)
	l = sorted(l)
	for i in range(0, len(l)):
		if l[i] >= 0:
			l[i] = str(l[i])
			if l[i][len(l[i]) - 1] == '0':
				print(l[i])
				break


n = int(input())
if n % 10 > 5:
	n = n // 10
	n = n + 1
	n = n * 10
else:
	n = n // 10
	n = n * 10
print(n)


n = int(input())
x = n // 10 * 10
if n - x > 5:
	print(int(x + 10))
else:
	print(int(x))


a = int(input())
if a % 10 <= 5:
	if a < 10:
		print(0)
	else:
		print(str(a // 10) + '0')
elif a < 10:
	print(10)
else:
	print(a + 10 - a % 10)


a = int(input())
if a % 10 == 0:
	print(a)
elif a % 10 <= 5:
	a = int(a / 10)
	r = int(a * 10)
	print(r)
else:
	a = a / 10
	q = int(a)
	q = q + 1
	b = int(q * 10)
	print(b)


import math
n = int(input())
s = str(n)
if s[len(s) - 1] == '0':
	print(n)
else:
	val = int(s[len(s) - 1])
	if val > 5:
		print(n + (10 - val))
	else:
		print(n - val)


n = int(input())
down = 10
up = 10
for i in range(6):
	f = n - i
	if f % 10 == 0:
		down = i
		break
for i in range(6):
	f = n + i
	if f % 10 == 0:
		up = i
		break
if down <= up:
	print(n - down)
else:
	print(n + up)


n = int(input())
d = n // 10
a1 = d * 10
a2 = (d + 1) * 10
if abs(a1 - n) > abs(a2 - n):
	print(a2)
else:
	print(a1)


n = int(input())
if n % 10 == 0:
	print(n)
elif n % 10 < 6:
	print(n - n % 10)
else:
	print(n + 10 - n % 10)


nn = input()
sz = len(nn)
a = nn[sz - 1]
b = nn[sz - 2]
xx = 10 - int(a)
n = 0
if xx < 5:
	n = int(nn) + xx
else:
	n = int(nn) - int(a)
print(n)


x = int(input())
if x % 10 == 0:
	print(x)
else:
	a = str(x)
	if a[-1] > '5':
		if a[-1] == '6':
			print(x + 4)
		elif a[-1] == '7':
			print(x + 3)
		elif a[-1] == '8':
			print(x + 2)
		elif a[-1] == '9':
			print(x + 1)
	else:
		print(x - x % 10)


n = int(input())

def f(n):
	rem = n % 10
	if rem <= 5:
		n -= rem
	else:
		n += 10 - rem
	return n
print(f(n))


n = int(input())
u_digit = n % 10
if u_digit > 5:
	print(n + 10 - u_digit)
else:
	print(n - u_digit)


n = int(input())
r = n % 10
if n <= 9:
	if n <= 5:
		print(0)
	else:
		print(10)
elif r <= 5:
	print(n - r)
else:
	print(n + (10 - r))


n = int(input())
a = n % 10
if 0 <= a < 6:
	print(n - a)
else:
	print(n + (10 - a))


n = int(input())
if n % 10 == 0:
	print(n)
elif n % 10 < 6:
	print(n - n % 10)
elif n % 10 > 5:
	print(n + 10 - n % 10)


n = int(input())
last = n % 10
if last == 5:
	print(n - 5)
elif last < 5:
	print(n - last)
else:
	add = 10 - last
	print(n + add)


def solve(n):
	if n % 10 <= 5:
		return 10 * (n // 10)
	else:
		return 10 * (n // 10) + 10

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


import math
n = input()
n = int(n)
if 0 <= n % 10 <= 5:
	n = n // 10 * 10
else:
	n = (n // 10 + 1) * 10
print(n)


import math
n = int(input())
if n == 0:
	print(0)
elif n < 5:
	print(0)
elif n > 5 and n < 10:
	print(10)
elif n % 10 == 0 and n != 0:
	print(n)
elif n % 10 <= 5:
	m = math.floor(n / 10) * 10
	print(m)
else:
	m = math.floor(n / 10) * 10 + 10
	print(m)


n = int(input())
strn = str(n)
final = strn[-1]
if final != '0' and final <= '5':
	n -= int(final)
elif final != '0' and final > '5':
	n += 10 - int(final)
print(n)


i = int(input())
n = list(str(i))
a = int(n[-1])
if a <= 5:
	n[-1] = '0'
	print(''.join(n))
else:
	print(i + 10 - a)


n = int(input())
rem = n % 10
if rem <= 5:
	print(n - rem)
else:
	print(n + 10 - rem)


n = int(input())
d = n % 10
num = 10 - d
if d == 0:
	print(n)
elif d <= 5:
	print(n - d)
else:
	print(n + num)


n = int(input())
k = n % 10
if 5 < k:
	d = 10 - k
	r = n + d
elif 5 >= k:
	r = n - k
print(r)


s = input()
if len(s) == 1:
	if int(s[0]) <= 5:
		print(0)
	else:
		print(10)
	exit()
if int(s) % 10 > 5:
	print(int(s) + (10 - int(s) % 10))
else:
	print(int(s) - int(s) % 10)


n = int(input())
d = n % 10
if d == 0:
	print(n)
elif d > 0 and d <= 5:
	print(n - d)
else:
	print(n + (10 - d))


inp = int(input())
a = inp % 10
if a == 0:
	print(inp)
elif a > 5:
	print('{}'.format(inp - a + 10))
else:
	print('{}'.format(inp - a))


def fun(n):
	x = [int(a) for a in str(n)]
	first = x[0]
	last = x[len(x) - 1]
	A = abs(n + (10 - last))
	B = abs(n - last)
	A1 = abs(A - n)
	B1 = abs(B - n)
	if A1 < B1:
		print(A)
	else:
		print(B)
n = int(input())
fun(n)


n = int(input())
x = n // 10
y = x * 10
if abs(y - n) > 5:
	print(y + 10)
else:
	print(y)


n = int(input())
ans = n
d = 100
if n <= 5:
	print(0)
	exit()
elif n <= 10:
	print(10)
	exit()
ans = []
l = []
for i in range(n - 10, n + 10):
	if i % 10 == 0:
		l.append([abs(n - i), i])
l.sort()
print(l[0][1])


n = int(input())
z = n % 10
if z <= 5:
	print(n - z)
else:
	print(n - z + 10)


num = int(input())
while num % 10 != 0:
	ans = num % 10
	if ans <= 5:
		num -= ans
	else:
		num += 10 - ans
print(num)


n = int(input())
k = n // 10 * 10
p = n // 10 * 10 + 10
if p - n < n - k:
	print(p)
else:
	print(k)


n = int(input())
q = n % 10
if q <= 5:
	print(n - q)
else:
	print(n + 10 - q)


try:
	n = int(input())
	if n % 10 < 6:
		print(n - n % 10)
	else:
		print(n + (10 - n % 10))
except:
	pass


x = eval(input())
y = x % 10
m = x // 10
if y <= 5:
	m = m * 10
elif y > 5:
	m = m * 10 + 10
print(m)


x = int(input())
while x % 10 != 0:
	if x % 10 <= 5:
		x -= x % 10
	else:
		x += 10 - x % 10
print(x)


src = input()
x = int(src)
a = x // 10 * 10
b = (x // 10 + 1) * 10
if b - x < x - a:
	print(b)
else:
	print(a)


def rounding(num):
	num = str(num)
	v = num
	rounddown = ['1', '2', '3', '4', '5']
	roundup = ['6', '7', '8', '9']
	if num[-1] == '0':
		return num
	elif num[-1] in rounddown:
		num = int(num)
		return num // 10 * 10
	elif num[-1] in roundup:
		num = int(num)
		return (num // 10 + 1) * 10
a = int(input())
print(rounding(a))


n = int(input())
r = n % 10
if r <= 5:
	n -= r
else:
	n += 10 - r
print(n)


n = input()
if 0 <= int(n) % 10 <= 5:
	ans = n[:len(n) - 1] + '0'
	print(ans)
else:
	ans = int(n) + 10 - int(n) % 10
	print(ans)


from sys import stdin, stdout
n = int(stdin.readline())
if str(n)[-1] == '0':
	stdout.write(str(n))
else:
	for i in range(11):
		if str(n - i)[-1] == '0':
			stdout.write(str(n - i))
			break
		elif str(n + i)[-1] == '0':
			stdout.write(str(n + i))
			break


n = int(input())
eq = n % 10
if eq > 5:
	print(n + 10 - eq)
else:
	print(n - eq)


import sys
n = list(input())
if len(n) == 0:
	if int(n) <= 5:
		print(0)
	else:
		print(10)
	sys.exit(0)
if n[-1] == '0':
	print(''.join(n))
else:
	tmp = int(n[-1])
	if tmp <= 5:
		n[-1] = '0'
	else:
		ans = int(''.join(n)) - tmp + 10
		n = list(str(ans))
	print(''.join(n))


t = int(input())
if t % 10 > 5:
	t += 10
print(t - t % 10)


s = input()
n = int(s)
last = s[-1]
if int(last) == 0:
	print(s)
elif int(last) <= 5:
	count = 0
	while count != 1:
		n = n - 1
		s1 = str(n)
		l = s1[-1]
		if l == '0':
			count = 1
	print(n)
else:
	count = 0
	while count != 1:
		n = n + 1
		s1 = str(n)
		l = s1[-1]
		if l == '0':
			count = 1
	print(n)


n = int(input())
low = n - n % 10
high = n + (10 - n % 10)
if high - n < n - low:
	print(high)
else:
	print(low)


read = lambda : map(int, input().split())
n = input()
if int(n[-1]) <= 5:
	print(n[:-1] + '0')
else:
	print((int(n) + 5) // 10 * 10)


N = input()
ln = len(N)
if int(N) < 10:
	print(0 if int(N) <= 5 else 10)
elif 10 - int(N[ln - 1]) < 5:
	print(int(N[:ln - 1]) + 1, 0, sep='')
else:
	print(int(N[:ln - 1]), 0, sep='')


s = int(input())
n = s % 10
need = 0
if n > 5:
	need = 10 - n
	print(s + need)
else:
	print(s - n)


def solve():
	c = int(input())
	a = c // 10 * 10
	b = a + 10
	if c - a > b - c:
		print(b)
	else:
		print(a)
solve()


n = int(input())
if n % 10 == 0:
	print(n)
else:
	k = n
	while k % 10 != 0:
		k = k + 1
	p = n
	while p % 10 != 0:
		p = p - 1
	if k - n < n - p:
		print(k)
	else:
		print(p)


s = int(input())
r = s % 10
if r > 5:
	r1 = 10 - r
	n1 = s + r1
else:
	n1 = s - r
print(n1)


x = input()
if int(x[-1]) == 0:
	print(x)
elif int(x[-1]) > 0 and int(x[-1]) <= 5:
	print(int(x) - int(x[-1]))
elif int(x[-1]) > 5 and int(x[-1]) <= 9:
	print(int(x) - int(x[-1]) + 10)


n = input()
m = int(n[-1:])
n = int(n)
if m == 0:
	print(n)
elif m == 5:
	print(n - 5)
elif m > 5:
	print(n + 10 - m)
elif m < 5:
	print(n - m)


n = input()
p = n[-1]
if int(p) <= 5:
	print(n[:-1] + '0')
else:
	m = int(n) % 10
	print(int(n) + 10 - m)


n = input()
if int(n[len(n) - 1]) <= 5:
	print(n[:len(n) - 1] + '0')
elif int(n[len(n) - 1]) >= 6:
	print(str(int(n) + (10 - int(n[len(n) - 1]))))


n = int(input())
num = n % 10
n = n // 10
if num <= 5:
	n = n * 10
if num > 5:
	n = n + 1
	n = n * 10
print(n)


n = int(input())
if n % 10 == 0:
	print(n)
elif n % 10 != 0 and n % 10 <= 5:
	print(n - n % 10)
elif n % 10 != 0 and n % 10 > 5:
	print(n + (10 - n % 10))


n = int(input())
count = 0
while n % 10 != 0:
	n += 1
	count += 1
if count < 5:
	print(n)
else:
	print(n - 10)


l = list(map(int, input().strip()))
s = len(l)
flag = 0
if l[s - 1] <= 5:
	l[s - 1] = 0
	for i in l:
		print(i, end='')
	print
elif s > 1:
	l[s - 1] = 0
	n = s - 2
	while l[n] == 9:
		l[n] = 0
		n -= 1
		if n < 0:
			flag = 1
			break
	else:
		l[n] += 1
		for i in l:
			print(i, end='')
		print()
	if flag == 1:
		print(1, end='')
		for i in range(s):
			print(0, end='')
else:
	print(10)


import sys
from collections import *
from math import *
import re

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

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

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

def even(n):
	return [False, True][0 if n % 2 else 1]
max_int = sys.maxsize
mod = 10 ** 9 + 7
n = input()
if n[-1] <= '5':
	n = int(n) - int(n[-1])
else:
	n = int(n) + 10 - int(n[-1])
print(n)


n = int(input())
x = str(n)
nn = len(x)
y = n % 10
z = int(n / 10)
if y > 5:
	if z == 0:
		print('10')
	else:
		print(str(z + 1) + '0')
elif z == 0:
	print('0')
else:
	print(str(z) + '0')


x = int(input())
a = x - 1
b = x - 2
c = x - 3
d = x - 4
e = x - 5
f = x + 4
g = x + 3
h = x + 2
i = x + 1
if x % 10 == 0:
	print(x)
elif a % 10 == 0:
	print(a)
elif b % 10 == 0:
	print(b)
elif c % 10 == 0:
	print(c)
elif d % 10 == 0:
	print(d)
elif e % 10 == 0:
	print(e)
elif f % 10 == 0:
	print(f)
elif g % 10 == 0:
	print(g)
elif h % 10 == 0:
	print(h)
elif i % 10 == 0:
	print(i)


import cmath
n = int(input())
a = n // 10 * 10
b = a + 10
if n - a > b - n:
	print(b)
else:
	print(a)


n = int(input())
a = int(str(n)[::-1][0])
if a > 10 - a:
	print(n + 10 - a)
else:
	print(n - a)


n = int(input())
t = n % 10
if t <= 5:
	print(n - t)
else:
	print(n + (10 - t))


import math
import decimal
n = input()
if int(n) % 10 > 5:
	z = int(str(math.ceil(int(n) / 10)) + '0')
elif int(n) % 10 <= 5:
	z = int(str(math.floor(int(n) / 10)) + '0')
print(z)


n = int(input())
d = n % 10
if d > 5:
	ans = n + (10 - d % 10)
else:
	ans = n - d
print(ans)


def main():
	n = int(input())
	remainder = n % 10
	if remainder <= 5:
		print(n - remainder)
	else:
		print(n + (10 - remainder))
main()


n = eval(input())
r = 0
if n % 10 > 5:
	r = (n // 10 + 1) * 10
else:
	r = n // 10 * 10
print(r)


a = int(input())
i = 0
j = 0
x = 0
y = 0
for i in range(10):
	v = a + i
	lst = list(str(v))
	r = len(lst)
	x = x + 1
	if lst[r - 1] == '0':
		p = v
		break
for j in range(10):
	t = a - j
	lst1 = list(str(t))
	f = len(lst1)
	y = y + 1
	if lst1[f - 1] == '0':
		q = t
		break
e = x - 1
w = y - 1
if e < w:
	print(p)
else:
	print(q)


n = int(input())
print(n + min(-(n % 10), 10 - n % 10, key=lambda x: abs(x)))


a = input()
d = a[len(a) - 1]
k = 0
if d > '5' and d > '0':
	k = int(a)
	if d == '6':
		k += 4
	if d == '7':
		k += 3
	if d == '8':
		k += 2
	if d == '9':
		k += 1
elif d <= '5' and d > '0':
	k = int(a)
	if d == '1':
		k -= 1
	if d == '2':
		k -= 2
	if d == '3':
		k -= 3
	if d == '4':
		k -= 4
	if d == '5':
		k -= 5
else:
	k = int(a)
print(k)


def rounded(n):
	if n % 10 > 5:
		return n + (10 - n % 10)
	return n - n % 10
n = int(input())
print(rounded(n))


n = int(input())
x = n % 10
n = int(n / 10)
if x > 5:
	n += 1
n = n * 10
print(n)


n = int(input())
k = n % 10
if k > 10 - k:
	ans = n + 10 - k
else:
	ans = n - k
print(ans)


n = int(input())
n1 = n
number = str(n)
a = len(number)
counter = 0
count = 0
if number[a - 1] == '0':
	print(n)
else:
	while True:
		n = n + 1
		counter = counter + 1
		b = str(n)
		c = len(b)
		if b[c - 1] == '0':
			d = n
			break
		else:
			continue
	count = count + int(number[a - 1])
	difference = n1 - int(number[a - 1])
	if count > counter:
		print(d)
	else:
		print(difference)


n = int(input())

def get_closest(n, up):
	s = 0
	while n % 10 != 0:
		n += up
		s += 1
	return (n, s)
f = get_closest(n, 1)
s = get_closest(n, -1)
print(f[0] if f[1] < s[1] else s[0])


i = int(input())
if i % 10 <= 5:
	print(i - i % 10)
else:
	i += 10
	print(i - i % 10)


x = int(input())
if int(x) % 10 > 5:
	c = int(x) // 10 + 1
	print(c * 10)
elif int(x) % 10 < 5:
	c = int(x) // 10
	print(c * 10)
else:
	c = int(x) // 10
	print(c * 10)


x = int(input())
a = x % 10
x = x // 10
if a <= 5:
	x = x * 10
else:
	x = x * 10 + 10
print(x)


import math
n = int(input())
num = str(n)
if n > 0 and n <= 5:
	num = '0'
elif n > 5 and n < 10:
	num = '10'
elif int(num[-1]) <= 5 and int(num[-1]) != 0:
	num = num[:-1] + '0'
elif int(num[-1]) > 5 and int(num[-1]) != 0:
	num = str(int(num[:-1]) + 1) + '0'
print(int(num))


q = int(input())
h = q % 10
if h <= 5:
	print(q - h)
else:
	h = 10 - h
	print(q + h)


n = int(input())
a = str(n)
b = int(a[-1])
c = 0
if b == 0:
	print(n)
elif 1 <= b < 6:
	print(n - b)
else:
	c = 10 - b
	print(n + c)


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from heapq import *
from copy import deepcopy
from collections import deque
from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

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

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

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

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

class IOWrapper(IOBase):

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

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

def iterative(f, stack=[]):

	def wrapped_func(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		to = f(*args, **kwargs)
		while True:
			if type(to) is GeneratorType:
				stack.append(to)
				to = next(to)
				continue
			stack.pop()
			if not stack:
				break
			to = stack[-1].send(to)
		return to
	return wrapped_func
mod = 10 ** 9 + 7

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

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

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

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

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

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

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

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

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

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

def google(p):
	print('Case #' + str(p) + ': ', end='')

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

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 ncr(n, r):
	return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))

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

def solve(case):
	n = list(inp())
	ll = len(n)
	if int(n[ll - 1]) <= 5:
		n[ll - 1] = '0'
		print(''.join((str(n[i]) for i in range(len(n)))))
	else:
		n[ll - 1] = '0'
		temp = int(''.join(n))
		temp += 10
		print(temp)
testcase(1)


import math
a = int(input())
b = [1, 2, 3, 4, 5]
if a % 10 == 0:
	print(a)
else:
	if a % 10 in b:
		a = math.floor(a / 10) * 10
	else:
		a = math.ceil(a / 10) * 10
	print(a)


n = int(input())
k = n % 10
if k <= 5:
	c = n // 10 * 10
else:
	c = (n // 10 + 1) * 10
print(c)


n = int(input())
str_n = str(n)
diff = int(str_n[len(str_n) - 1]) - 0
if diff <= 5:
	print(n - diff)
else:
	print(n + (10 - diff))


s = int(input())
if s % 10 <= 5:
	print(s - s % 10)
else:
	print(s + 10 - s % 10)


n = int(input())
ans = n % 10
if ans == 0:
	print(n)
elif ans > 5:
	print(n + 10 - ans)
else:
	print(n - ans)


n = int(input())
w = n % 10
if w > 5:
	t = int(n // 10)
	r = (t + 1) * 10
	print(r)
if w <= 5:
	t = int(n // 10)
	r = t * 10
	print(r)


N = int(input())
a = N % 10
if a > 0 and a <= 5:
	N = N - a
elif a > 5:
	N = N + 10 - a
print(N)


num = int(input())
r = num % 10
if r <= 5:
	print(num - r)
else:
	print(num + (10 - r))


n = int(input())
if n % 10 == 0:
	print(n)
else:
	r = n % 10
	k = n - r
	l = k + 10
	if n - k <= l - n:
		print(k)
	else:
		print(l)


n = str(input())
x = int(n)
if int(n[-1]) <= 5:
	x -= int(n[-1])
else:
	x += 10 - int(n[-1])
print(x)


i = int(input())
while i % 10 != 0:
	k = str(i)
	if int(k[-1]) <= 5:
		i = i - 1
	else:
		i = i + 1
print(i)


n = input()
if 5 < int(n) < 11:
	print(10)
	exit(0)
elif -1 < int(n) < 6:
	print(0)
	exit(0)
n = list(n)
if int(n[-1]) > 5:
	i = 2
	n[-1] = '0'
	n[-2] = int(n[-2]) + 1
	while i != len(n):
		if int(n[-i]) == 10:
			n[-i] = '0'
			n[-i - 1] = int(n[-i - 1]) + 1
		else:
			break
		i += 1
else:
	n[-1] = '0'
print(''.join(map(str, n)))


n = int(input())
c = 0
if n % 2 == 0 and n % 5 == 0:
	print(n)
else:
	x = n
	while not (x % 2 == 0 and x % 5 == 0):
		c += 1
		x += 1
	if c < 5:
		print(x)
	else:
		print(n - (10 - c))


n = int(input())
s = str(n)
if s[-1] == '0':
	print(n)
else:
	n1 = n - int(s[-1])
	n2 = n1 + 10
	if n - n1 <= n2 - n:
		print(n1)
	else:
		print(n2)


n_str = input()
n = int(n_str)
last_digit = int(n_str[-1])
if last_digit > 5:
	n += 10 - last_digit
else:
	n -= last_digit
print(n)


n = input()
l = len(n)
if int(n[-1]) <= 5:
	print(int(n) - int(n[-1]))
else:
	print(int(n) + 10 - int(n[-1]))


n = list(input())
if int(n[-1]) <= 5:
	print(''.join(n[0:-1]) + '0')
else:
	n = int(''.join(n))
	while n % 10 != 0:
		n += 1
	print(n)


s = input()
n = len(s)
if int(s[n - 1]) > 5:
	s = int(int(s) / 10) * 10 + 10
	print(s)
elif int(s[n - 1]) <= 5:
	s = list(s)
	s[n - 1] = '0'
	print(''.join(s))
elif int(s[n - 1]) == 0:
	print(s)


import math
import sys
import itertools
import itertools
import bisect

def sa(Type=int):
	return [Type(x) for x in input().split()]

def solve(t):
	n = int(input())
	lastDigit = n % 10
	if lastDigit < 6:
		print(n // 10 * 10)
	else:
		print((n // 10 + 1) * 10)
solve(1)


n = int(input())
num = n
r = num % 10
if r == 0:
	print(num)
elif r > 0 and r <= 5:
	n = n - n % 10
	print(n)
else:
	n = n + (10 - r)
	print(n)


n = list(input())
if len(n) == 0:
	print(0)
elif n[len(n) - 1] != '0':
	if int(n[len(n) - 1]) > 5:
		temp = 10 - int(n[len(n) - 1])
		print(temp + int(''.join(n)))
	else:
		n[len(n) - 1] = '0'
		print(''.join(n))
else:
	print(''.join(n))


num = int(input())
if num % 10 < 6:
	print(num - num % 10)
else:
	print(num + (10 - num % 10))


import string
n = int(input())
s = str(n)
if int(s[len(s) - 1]) <= 5:
	n = n - int(s[len(s) - 1])
else:
	n = n + 10 - int(s[len(s) - 1])
print(n)


n = int(input())
r = n % 10
if r == 0:
	print(n)
elif r > 5:
	b = 10 - r
	print(n + b)
else:
	print(n - r)


a = int(input())
b = len(str(a))
g = a % 10
l = a // 10
if g <= 5:
	print(a - g)
else:
	print(l * 10 + 10)


def main():
	n = input()
	number = int(n)
	lists = list(map(int, str(number)))
	if number > 9:
		if lists[-1] <= 5:
			lists[-1] = 0
			x = ''
			for p in lists:
				x += str(p)
			print(x)
		else:
			nn = number
			while 1:
				lists = list(map(int, str(nn)))
				if lists[-1] == 0:
					break
				else:
					nn += 1
			print(nn)
	else:
		if number <= 5:
			number = 0
		else:
			number = 10
		print(number)
main()


a = int(input())
c = a % 10
if c <= 5:
	while c != 0:
		c -= 1
		a -= 1
else:
	while c != 10:
		c += 1
		a += 1
print(a)


u = int(input())
if u % 10 <= 5:
	print(u // 10 * 10)
else:
	print((u // 10 + 1) * 10)


n = int(input())
a = n % 10
b = int(str(n)[:-1] + str('0'))
if a == 0:
	print(n)
elif abs(n - b) > 5:
	print(10 - abs(n - b) + n)
else:
	print(b)


n = int(input())
if n % 10 == 0:
	print(n)
elif n < 5:
	print('0')
elif n > 5 and n < 9:
	c = 10 - n
	print(n + c)
else:
	c = n % 10
	if c > 5:
		c = 10 - c
		print(n + c)
	else:
		n -= c
		print(n)


a = int(input())
if a % 10 is 0:
	print(a)
	exit(0)
b = a % 10
if b <= 5:
	print(a - b)
	exit(0)
else:
	print(a + (10 - b))
	exit(0)


c = int(input())
if c % 10 >= 6:
	print(c // 10 * 10 + 10)
else:
	print(c // 10 * 10)


s = input()
if int(s[len(s) - 1]) <= 5:
	print(int(s) // 10 * 10)
else:
	print(int(s) // 10 * 10 + 10)


n = int(input())
if n <= 5:
	print('0')
	exit()
elif n > 5 and n <= 10:
	print('10')
	exit()
elif n % 10 == 0:
	print(n)
	exit()
else:
	a = n // 10
	b = a * 10
	c = a + 1
	if c * 10 - n < n - b:
		print(c * 10)
	else:
		print(b)


import math
import sys
n = int(sys.stdin.readline().strip())
if int(str(n)[-1]) > 5:
	print(int(math.ceil(n / 10.0)) * 10)
else:
	print(int(n / 10.0) * 10)


i = input()
a = list(i)
if len(a) == 1:
	if int(a[0]) < 6:
		a[0] = 0
	else:
		a[0] = 10
elif int(a[-1]) <= 5:
	a[-1] = 0
else:
	i = 2
	a[-1] = 0
	a[-2] = int(a[-2]) + 1
	while i < len(a) and int(a[-i]) == 10:
		if a[-i] == 10:
			a[-i] = 0
		i += 1
		a[-i] = int(a[-i]) + 1
for i in a:
	print(int(i), end='')


import sys
n = int(input())
print(n - n % 10 if n % 10 <= 5 else n - n % 10 + 10)


a = input()
if int(a[len(a) - 1]) < 6:
	print(int(a) - int(a[len(a) - 1]))
else:
	print(int(a) + (10 - int(a[len(a) - 1])))


n = int(input())
c = n % 10
if c == 0 or c == 1 or c == 2 or (c == 3) or (c == 4) or (c == 5):
	print(n - c)
else:
	print(n + (10 - c))


n = int(input())
n2 = n
c1 = 0
c2 = 0
while n % 10 != 0:
	if int(str(n)[-1]) <= 5:
		n -= 1
	else:
		n += 1
print(n)


n = int(input())

def foo(n):
	if n % 10 > 5:
		return int(n / 10) * 10 + 10
	else:
		return int(n / 10) * 10
print(foo(n))


n = input()
length = len(n)
if length == 1 and int(n) <= 5:
	print(0)
	exit(0)
if length == 1 and int(n) > 5:
	print(10)
	exit(0)
if n[length - 1] == '0':
	print(n)
	exit(0)
name = ''
if n[length - 1] > '5':
	name = int(n[:-1])
	name += 1
	print(str(name) + '0')
	exit(0)
elif n[length - 1] <= '5':
	for i in range(length):
		if i == length - 1:
			name += '0'
		else:
			name += n[i]
print(name)


n = int(input())
s = int(str(n)[-1])
a = n - s
b = n + (10 - n % 10)
if min(n - a, b - n) == n - a:
	print(a)
else:
	print(b)


n = int(input())
plus = n
minus = n
while plus:
	m = list(str(plus))
	if m[len(m) - 1] == '0':
		break
	plus += 1
while minus > -1:
	m = list(str(minus))
	if m[len(m) - 1] == '0':
		break
	minus -= 1
a = plus - n
b = n - minus
if a == b:
	print(n - a)
elif a > b:
	print(n - b)
elif b > a:
	print(n + a)


n = int(input())
print((n + 4) // 10 * 10)


n = int(input())
if n % 10 == 0:
	print(n)
	exit(0)
if abs(n // 10 * 10 - n) <= abs((n // 10 + 1) * 10 - n):
	print(n // 10 * 10)
else:
	print((n // 10 + 1) * 10)


n = int(input())
s = str(n)
if int(s[-1]) == 0:
	print(n)
	exit()
if int(s[-1]) <= 5:
	n -= int(s[-1])
else:
	n += abs(10 - int(s[-1]))
print(n)


n = int(input())
s = str(n)
l = list(s)
if int(s[-1]) == 0:
	print(n)
elif int(s[-1]) > 0 and int(s[-1]) <= 5:
	l[-1] = '0'
	print(*l, sep='')
else:
	n = n + 10 % int(s[-1])
	print(n)


n = int(input())
a = n
c1 = 0
b = n
c2 = 0
while a % 10 != 0:
	a += 1
	c1 += 1
while b % 10 != 0:
	b -= 1
	c2 += 1
if c1 < c2:
	print(a)
else:
	print(b)


n = input('')
if int(n[len(n) - 1]) < 5:
	print(int(n) - int(n[len(n) - 1]))
elif int(n[len(n) - 1]) > 5:
	print(int(n) - int(n[len(n) - 1]) + 10)
else:
	print(int(n) - int(n[len(n) - 1]))


def rnd(n):
	x = n % 10
	if x > 5:
		return n + (10 - x)
	else:
		return n - x
n = input()
print(rnd(int(n)))


num = int(input())
if num % 10 == 0:
	print(num)
	quit()
srem = num % 10
a = num - srem
b = 1000
for i in range(1, 10):
	if (num + i) % 10 == 0:
		b = num + i
		brem = i
		break
rem = min(srem, brem)
if rem == srem:
	print(a)
	quit()
print(b)


s = input()
if int(s[-1]) == 0:
	print(s)
elif int(s[-1]) > 0 and int(s[-1]) <= 5:
	print(int(s) - int(s[-1]))
else:
	print(int(s) - int(s[-1]) + 10)


__author__ = 'Dilshod'
n = input()
if len(n) == 1:
	if int(n) <= 5:
		print(0)
	else:
		print(10)
	exit()
if int(n[-1]) > 5:
	n = str(int(n[:-1]) + 1) + '0'
else:
	n = n[:-1] + '0'
print(n)


a = int(input())
x = [1, 2, 3, 4, 5]
y = [6, 7, 8, 9]
z = int(str(a)[-1])
if z == 0:
	print(a)
elif z in x:
	print(a - z)
elif z in y:
	print(a + 10 - z)


n = int(input())
k = n % 10
h = 0
if k <= 5:
	h = n - k
else:
	h = n + 10 - k
print(h)


n = int(input())
mod = n % 10
if mod == 0:
	print(n)
elif mod == 5:
	print(n - 5)
elif mod < 5:
	did = n - mod
	print(did)
else:
	dif = 10 - mod
	sum = n + dif
	print(sum)


from sys import stdin, stdout
import math
import heapq
from itertools import accumulate
N = int(input())
module = N % 10
if module <= 5:
	print(N - module)
else:
	print(N + 10 - module)


x = int(input())
if x % 10 == 0:
	print(x)
else:
	a = x // 10 * 10
	b = (x // 10 + 1) * 10
	if abs(x - a) > abs(x - b):
		print(b)
	else:
		print(a)


a = int(input())
last_number = int(str(a)[-1])
if last_number == 0:
	print(a)
elif 10 - last_number < last_number:
	print(a - last_number + 10)
else:
	print(a - last_number)


def rounding(n):
	m = n % 10
	if n % 10 == 0:
		return n
	elif m <= 5:
		return n - m
	else:
		return n + (10 - m)
n = int(input())
print(rounding(n))


n = input().strip()
lastd = int(n[-1])
n = int(n)
if lastd > 5:
	n += 10 - lastd
else:
	n -= lastd
print(n)


n = int(input())
rem = n % 10
if rem == 0:
	print(n)
elif rem in range(1, 6):
	print(n - rem)
else:
	print(n + 10 - rem)


n = int(input())
t = str(n)
if n < 6:
	print('0')
elif n < 10:
	print('10')
else:
	k = n % 10
	if k == 0:
		print(n)
	elif k > 5:
		g = n // 10
		str_ = str(g)
		add_ = str_ + '0'
		int_ = int(add_)
		print(int_ + 10)
	else:
		print(n - k)


num = int(input())
unit = num % 10
if unit <= 5:
	print(num - unit)
else:
	print(num + (10 - unit))


num = input()
last = num[-1]
if last in '012345':
	print(num[:-1] + '0')
else:
	print(int(num) // 10 * 10 + 10)


n = int(input())
n1 = str(n)
last = n1[-1]
l = int(last)
if l > 5:
	n = n + (10 - l)
else:
	n = n - l
print(n)


a = int(input())
if a % 10 == 0:
	print(a)
elif a % 10 <= 5:
	print(a - a % 10, end='')
elif a % 10 > 5:
	print(a + 10 - a % 10)


n = input()
m = int(n)
n = list(n)
k = int(n[len(n) - 1])
if 0 < k < 6:
	print(m - k)
if 5 < k < 10:
	k = 10 - k
	print(m + k)
if k == 0:
	print(m)


n = int(input())
if n == 0:
	print(n)
	exit()
for i in range(n):
	if n % 10 != 0 and int(str(n)[-1]) > 5 or (n > 6 and n < 10):
		n += 1
	elif n < 10:
		print(0)
		exit()
	elif n % 10 == 0:
		print(n)
		exit()
	else:
		n -= 1


a = int(input())
b = str(a)
c = len(b)
if int(b[c - 1]) > 5:
	a = a - int(b[c - 1]) + 10
else:
	a = a - int(b[c - 1])
print(a)


n = int(input())
temp = str(n)
if temp[-1] == '0':
	output = n
elif int(temp[-1]) <= 5:
	output = n - int(temp[-1])
else:
	output = n + 10 - int(temp[-1])
print(output)


import math
n = int(input())
if n % 10 <= 5:
	ans = 10 * (n // 10)
else:
	ans = 10 * (n // 10 + 1)
print(ans)


a = int(input())
if abs(10 - a % 10) < a % 10:
	print(a + (10 - a % 10))
else:
	print(a - a % 10)


x = int(input())
p = x % 10
if p == 0:
	print(x)
elif p <= 5:
	print(x - p)
else:
	print(x + 10 - p)


n = int(input().strip())
x = n % 10
if x > 5:
	n = n + 10 - x
elif not x == 0:
	n = n - x
print(n)


s = input()
n = len(s)
a = int(s[n - 1])
if a < 6:
	s = s[:n - 1] + '0'
	print(s)
else:
	s = s[:n - 1] + '0'
	s = int(s) + 10
	print(s)