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
Tags: Mathematics

Implementation

Starter code:

Solutions:
a = int(input())
b = a
c = list(str(b))
if int(c[-1]) >= 5:
	a += int(10 - int(c[-1]))
	print(int(a))
elif int(c[-1]) < 5:
	a -= int(c[-1])
	print(int(a))


def read_int():
	return int(input())

def read_ints():
	return [int(x) for x in input().split()]
n = read_int()
if n % 10 < 5:
	print(n - n % 10)
else:
	print(n + (10 - n % 10))


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)


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


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


import sys, math
input = sys.stdin.readline
print = sys.stdout.write
L = lambda : list(map(int, input().split().strip()))
M = lambda : map(int, input().split())
a = int(input())
if a % 10 >= 5:
	a += 10 - a % 10
else:
	a -= a % 10
print(str(a))


import math
n = int(input())
(down, up) = (math.floor(n / 10) * 10, math.ceil(n / 10) * 10)
print(down if math.fabs(n - down) < math.fabs(n - up) else up)


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


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


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


import bisect

def list_output(s):
	print(' '.join(map(str, s)))

def list_input(s='int'):
	if s == 'int':
		return list(map(int, input().split()))
	elif s == 'float':
		return list(map(float, input().split()))
	return list(map(str, input().split()))
n = int(input())
x = n // 10 * 10
y = x + 10
if abs(n - x) < abs(n - y):
	print(x)
else:
	print(y)


import math

def solve():
	n = int(input())
	while n % 10 != 0:
		if n % 10 >= 5:
			n += 1
		else:
			n -= 1
	return n
t = 1
for _ in range(t):
	print(solve())


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


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 = int(input())
print(n // 10 * 10 + (10 if n % 10 >= 5 else 0))


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')


from math import remainder
n = int(input())
print(int(n - remainder(n, 10)))


import sys
data = sys.stdin.readlines()
print(round(int(data[0]), -1))


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()


a = input()
x = int(a) - int(a[-1])
print(x + 10 if int(a[-1]) > 4 else x)


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 = int(input())
x = n % 10
if x == 0:
	print(n)
elif x >= 5:
	print(n + 10 - x)
else:
	print(n - x)


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)


def main():
	x = int(input())
	if x % 10 == 0:
		print(x)
	else:
		for i in range(1, 6):
			if (x + i) % 10 == 0 or (x - i) % 10 == 0:
				a = i
				break
		if (x + a) % 10 == 0:
			print(x + a)
		else:
			print(x - a)
main()


print(int(round(int(input()) / 10, 0)) * 10)


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


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


import sys
input = sys.stdin.readline
from collections import *
n = int(input())
if n % 10 <= 4:
	print(n // 10 * 10)
else:
	print((n + 9) // 10 * 10)


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())
ans = round(n / 10)
print(ans * 10)


n = int(input())
answer = 10 * round(n / 10)
print(answer)


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


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)


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


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)


n = int(input())
l = int(n % 10)
if l in range(1, 5):
	print(n - l)
elif l in range(5, 10):
	print(n + 10 - l)
else:
	print(n)


n = int(input())
mina = n
maxi = n
while str(mina)[-1] != '0':
	mina -= 1
while str(maxi)[-1] != '0':
	maxi += 1
if max(maxi, mina) - n > n - min(maxi, mina):
	print(mina)
else:
	print(maxi)


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())
if n % 10 <= 5:
	n = n - n % 10
elif n % 10 > 5:
	n = n + 10 - n % 10
print(n)


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


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 = list(input())
if int(''.join(n)) % 10 == 0:
	print(''.join(n))
elif int(''.join(n)) % 10 <= 5:
	print(int(''.join(n)) - int(''.join(n)) % 10)
else:
	print(int(''.join(n)) + (10 - int(''.join(n)) % 10))


import math

def me():
	number = int(input())
	num1 = number / 10
	num2 = round(num1)
	answer = num2 * 10
	print(answer)
me()


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())
f = n - n % 10
s = f + 10
if abs(n - f) < abs(s - n):
	print(f)
else:
	print(s)


s = input()
c = int(s[len(s) - 1])
y = int(s)
if y >= 10:
	y //= 10
	x = int(c)
	if x <= 5:
		print(str(y) + '0')
	else:
		y += 1
		print(str(y) + '0')
elif y <= 5:
	print(0)
else:
	print(10)


n = int(input())
a = b = n
while 1 and n % 10 != 0:
	a += 1
	b -= 1
	if a % 10 == 0:
		print(a)
		break
	elif b % 10 == 0:
		print(b)
		break
else:
	print(n)


from math import ceil
a = input()
b = len(a)
g = a[b - 1]
if int(g) <= 5:
	print(int(a) - int(g))
else:
	print(int(a) + 10 - int(g))


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


n = int(input())
m = n % 10
print(n - m + int(m / 6) * 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)


from math import ceil

def solve():
	n = int(input())
	if n % 10 == 0:
		print(n)
	elif n % 10 < 5:
		print(n // 10 * 10)
	else:
		print(int(ceil(n / 10)) * 10)
solve()


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


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)


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


val = int(input().strip())
val /= 10
val = round(val)
print(int(val) * 10)


z = input
n = int(z())
if n % 10 == 0:
	print(n)
	exit()
t = str(n)
if int(t[-1]) >= 5:
	j = 10 - int(t[-1])
	print(n + j)
if int(t[-1]) < 5:
	print(t[:-1] + '0')


n = int(input())
temp = n / 10.0
temp = round(temp)
n = int(temp * 10)
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)


a = int(input())
b = a // 10
s = str(b + int(a % 10 + 5) // 10)
if a >= 5:
	print(s + '0')
else:
	print(s)


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)


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


import math
from fractions import Fraction as frac
MOD = 1000000000.0 + 7

def solve(case_no):
	n = int(input())
	print(int(round(n / 10) * 10))
t = 1
for i in range(1, t + 1):
	solve(i)


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


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())
for i in range(100):
	if (n + i) % 10 == 0:
		print(n + i)
		break
	if (n - i) % 10 == 0:
		print(n - i)
		break


a = int(input())
b = a + 5
b -= b % 10
print(b)


def rounding(n):
	if n % 10 == 0:
		return n
	return int(round(n / 10.0)) * 10
m = int(input())
print(rounding(m))


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))


n = int(input())
s = list(str(n))
n1 = int(s[-1])
ans1 = 10 - n1
ans2 = n1 - 0
if n % 10 == 0:
	print(n)
elif ans1 > ans2:
	print(n - ans2)
else:
	print(n + ans1)


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)


import sys
integer = int(input())
rem = integer % 10
a = integer // 10
answer = a * 10
if rem >= 5:
	answer += 10
print(answer)


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)


n = int(input())
tmp1 = n // 10 * 10
tmp2 = (n + 10) // 10 * 10
if abs(n - tmp1) < abs(n - tmp2):
	print(tmp1)
else:
	print(tmp2)


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
if k >= 5:
	print(n + (10 - k))
else:
	print(n - k)


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


print(round(int(input()), -1))


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


print(round(int(input()) / 10) * 10)


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


n = input()
if n[-1] == 0:
	print(n)
elif int(n[-1]) > 4:
	n = int(n)
	print(n + (10 - n % 10))
else:
	n = int(n)
	print(n - n % 10)


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


n = int(input())
n = round(n / 10)
if n == 0:
	print('0')
else:
	print(str(n) + '0')


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)


s = int(input())
print(round(s / 10) * 10)


s = input()
if s[-1] == '0':
	print(int(s))
elif int(s[-1]) > 0 and int(s[-1]) < 5:
	x = int(s)
	y = x % 5
	z = x - y
	print(z)
elif int(s[-1]) > 5 and int(s[-1]) <= 9:
	x = int(s)
	y = x % 5
	z = x + (5 - y)
	print(z)
elif int(s[-1]) == 5:
	x = int(s)
	z = x + 5
	print(z)


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


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()
	if n % 10 < 5:
		return n - n % 10
	return n - n % 10 + 10
print(main())


a = int(input())
b = round(a / 10) * 10
print(b)


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)


num = int(input())
print(round(num, -1))


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)


a = float(input())
a = a / 100
a = round(a, 1)
print(int(a * 10) * 10)


n = int(input())
a1 = n - n % 10
a2 = n + (10 - n % 10)
if abs(a1 - n) < abs(a2 - n):
	print(a1)
else:
	print(a2)


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))


import random
num = str(input(''))
if num[-1] == '0':
	print(num)
elif num == '5':
	print(random.choice(['0', '10']))
elif num[-1] == '5':
	print(int(num) + 5)
elif 10 - int(num[-1]) > 5:
	print(int(num) - int(num[-1]))
else:
	print(int(num) + (10 - int(num[-1])))


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


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


import math
x = int(input()) / 10
if int(str(x)[-1]) <= 5:
	print(round(x) * 10)
else:
	print(math.ceil(x) * 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())
if n % 10 > 4:
	print(n + 10 - n % 10)
else:
	print(n - n % 10)


import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
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 I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def LS():
	return sys.stdin.readline().split()

def S():
	return input()

def main():
	n = I()
	n += 5
	n /= 10
	return int(n) * 10
print(main())


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)


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


n = int(input())
print(round(n, -1))


k = int(input())
l = k % 10
p = k // 10
if l < 5:
	print(k - l)
else:
	print((p + 1) * 10)


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


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


import sys
import math as mt
import bisect
t = 1

def solve():
	(n1, n2) = (0, 0)
	for i in range(11):
		if (n + i) % 10 == 0:
			n1 = i
			break
	for i in range(11):
		if (n - i) % 10 == 0:
			n2 = i
			break
	if n1 > n2:
		return n - n2
	else:
		return n + n1
for _ in range(t):
	n = int(input())
	print(solve())


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


import math
n = int(input())
n = n / 10
print(round(n) * 10)


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


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)


a = int(input())
if a % 10 == 0:
	print(a)
else:
	b = round(a / 10)
	print(b * 10)


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)


import math
print(math.floor((int(input()) + 5) / 10) * 10)


n = int(input())
(a, b) = (10 * (n // 10), 10 * (n // 10) + 10)
if n - a < b - n:
	print(a)
else:
	print(b)


x = int(input())
y = x
ans1 = 0
ans2 = 0
while x % 10 != 0:
	x -= 1
	ans1 += 1
while y % 10 != 0:
	y += 1
	ans2 += 1
if ans1 < ans2:
	print(x)
else:
	print(y)


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())
last_n = n % 10
result = n // 10
if last_n >= 5:
	result += 1
print(result * 10)


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)


a = int(input())
if a % 10 >= 5:
	print((a * 2 - a * 2 % 10) // 2 + 5)
else:
	print(a - a % 10)


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 = int(input())
a = str(n)
b = int(a[-1])
if b >= 5:
	n = n - b + 10
elif b < 5:
	n = n - b
print(n)


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)))


n = int(input())
remainder = n % 10
result = 0
if remainder >= 5:
	result = n + (10 - remainder)
if remainder < 5:
	if remainder == 0:
		result = n
	else:
		result = n - remainder
print(result)


z = input()
he = int(z)
while he % 10 != 0:
	if z[len(z) - 1] >= '5':
		he += 1
	else:
		he -= 1
print(he)


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)


n = list(map(int, input('').strip().split()))[0]
a = n % 10
if a >= 5:
	print(n - a + 10)
else:
	print(n - a)


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)


import sys
input = sys.stdin.readline
n = int(input())
print(round(n / 10) * 10)


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


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


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


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


n = int(input())
if n % 10 == 0 or n % 10 == 1 or n % 10 == 2 or (n % 10 == 3) or (n % 10 == 4):
	print(n - n % 10)
if n % 10 == 5 or n % 10 == 6 or n % 10 == 7 or (n % 10 == 8) or (n % 10 == 9):
	print(n + (10 - n % 10))


import sys
import math
import bisect

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


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)


n = int(input())
tot = (n + 5) // 10 * 10
print(str(tot))


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)


n = int(input())
for i in range(6):
	a = n + i
	b = n - i
	if a % 10 == 0:
		print(a)
		break
	if b % 10 == 0:
		print(b)


S = int(input())
ex = S % 10
if S % 10 != 0:
	if ex >= 5:
		S -= ex
		S += 10
	else:
		S -= ex
print(S)


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)


def find_min_zero(num):
	count1 = 0
	count2 = 0
	num1 = num
	num2 = num
	while num1 % 10 != 0:
		num1 += 1
		count1 += 1
	while num2 % 10 != 0:
		num2 -= 1
		count2 += 1
	if count1 > count2:
		return num2
	else:
		return num1
N = int(input().strip())
print(find_min_zero(N))


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())
k = n % 10
if k == 0:
	print(n)
elif k <= 4:
	print(n - n % 10)
else:
	print(n + (10 - k))


s = input()
if s.endswith('0') == True:
	print(s)
else:
	n = int(s)
	f = n / 10
	k = round(f)
	p = int(k * 10)
	print(str(p))


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)


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


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


from sys import stdin, stdout
import math
n = int(stdin.readline().rstrip())
print(round(n / 10) * 10)


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)


innum = float(input())
innum *= 0.1
ans = round(innum) * 10
print(ans)


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


from math import ceil
n = int(input())
print(round(n / 10) * 10)


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)))


num = input()
if num[-1] == '0':
	print(num)
else:
	num = int(num)
	num /= 10
	num = round(num)
	num *= 10
	print(num)


import math
import sys
import getpass
import bisect

def ria():
	return [int(i) for i in input().split()]
files = False
if getpass.getuser().lower() == 'frohe' and files:
	sys.stdin = open('test.in')
n = ria()[0]
print(int(round(n / 10) * 10))


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))


num = int(input())
if num >= 5 and num <= 10:
	print('10')
elif num >= 0 and num < 5:
	print('0')
else:
	print(str(round(num, -1)))


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


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)


import math
n = int(input())
a = 10 * (n // 10)
b = a + 10
if abs(n - a) < abs(n - b):
	print(a)
else:
	print(b)


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 = int(input())
d = n
while d % 10 != 0:
	d += 1
if d - n <= 5:
	print(d)
else:
	print(n - (10 - (d - n)))


import math as mt
import sys, string
from collections import Counter, defaultdict
input = sys.stdin.readline
I = lambda : int(input())
M = lambda : map(int, input().split())
ARR = lambda : list(map(int, input().split()))

def printARR(arr):
	for e in arr:
		print(e, end=' ')
	print()

def main():
	n = I()
	if n % 10 < 5:
		print(n - n % 10)
	else:
		print(n + (10 - n % 10))
tc = 1
for _ in range(tc):
	main()


print((lambda x: x - x % 10 if x % 10 < 5 else x - x % 10 + 10)(int(input())))


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())
m = round(n / 10) * 10
print(m)


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().strip())
re = a % 10
if a == re:
	print(0 if a < 5 else 10)
else:
	a -= re
	if re > 5:
		a += 10
	print(a)


from math import *
n = int(input())
x = n % 10
if x >= 5:
	print(n + 10 - x)
else:
	print(n - x)


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())
l = len(str(n))
i = n - n % 5
j = i + 5
if int(str(n)[l - 1]) >= 5:
	print(j)
else:
	print(i)


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)


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


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)


def solution():
	n = int(input())
	rem = n % 10
	if rem >= 5:
		res = n - rem + 10
	else:
		res = n - rem
	return res
print(solution())


n = int(input())
n1 = n // 10 * 10
n2 = (n // 10 + 1) * 10
print(n1 if n - n1 < n2 - n else n2)


n = input()
num = int(n)
x = list(map(int, n.strip()))
y = list(n.strip())
if len(x) == 1 and x != '5':
	if x[0] > 5:
		print(10)
	else:
		print(0)
elif int(x[-1]) < 5:
	y[-1] = '0'
	print(''.join(y))
else:
	while n[-1] != '0':
		num = num + 1
		n = str(num)
		if n[-1] == '0':
			print(num)


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)


import sys

def main():
	k = int(sys.stdin.read().strip())
	return k - k % 10 + (k % 10 > 4) * 10
print(main())


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])))


print(int(round(float(input()) * 0.1)) * 10)


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))


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


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))


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


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 = input()
if n.endswith('5'):
	n = int(n) + 5
elif int(n[len(n) - 1]) > 5:
	n = int(n) + (10 - int(n[len(n) - 1]))
elif int(n[len(n) - 1]) < 5:
	n = int(n) - int(n[len(n) - 1])
print(n)


import sys

def main():
	pass

def binary(n):
	return bin(n).replace('0b', '')

def decimal(s):
	return int(s, 2)

def pow2(n):
	p = 0
	while n > 1:
		n //= 2
		p += 1
	return p

def isPrime(n):
	if n == 1:
		return False
	else:
		root = int(n ** 0.5)
		root += 1
		for i in range(2, root):
			if n % i == 0:
				return False
		return True

def lts(l):
	s = ''.join(map(str, l))
	return s

def stl(s):
	l = list(s)
	return l

def sq(a, target, arr=[]):
	s = sum(arr)
	if s == target:
		return arr
	if s >= target:
		return
	for i in range(len(a)):
		n = a[i]
		remaining = a[i + 1:]
		ans = sq(remaining, target, arr + [n])
		if ans:
			return ans

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

def nCr(n, r):
	f = math.factorial
	return f(n) // f(r) // f(n - r)
mod = int(1000000000.0) + 7

def ssinp():
	return sys.stdin.readline().strip()

def iinp():
	return int(input())

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

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

def p(xyz):
	print(xyz)

def p2(a, b):
	print(a, b)
import math
n = input()
l = stl(n)
ans = int(n)
if int(l[-1]) <= 4:
	print(ans - int(l[-1]))
else:
	print(ans + 10 - int(l[-1]))


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())
z = str(n)
if int(z[-1]) >= 0 and int(z[-1]) < 5:
	print(n - int(z[-1]))
else:
	print(n + 10 - int(z[-1]))


def answer():
	a = int(input())
	if int(str(a)[-1]) < 5:
		a -= a % 10
	else:
		a += 10 - a % 10
	print(a)
answer()


n = float(input())
n /= 10
print(round(n) * 10)


from collections import Counter

def lInt(d=None):
	return map(int, input().split(d))
(n, *_) = lInt()
if n % 10 == 0:
	print(n)
	exit()
else:
	f = n - n % 10
	c = n + (10 - n % 10)
	if n - f < c - n:
		print(f)
	else:
		print(c)


n = int(input())
x = n % 10
y = 10 - n % 10
if x >= y:
	print(n + y)
else:
	print(n - x)


n = int(input())
down = n // 10 * 10
up = (n // 10 + 1) * 10
if abs(n - up) > abs(n - down):
	print(down)
else:
	print(up)


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)))


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


n = int(input())
s1 = n
s2 = n
while str(s1)[-1] != '0':
	s1 -= 1
while str(s2)[-1] != '0':
	s2 += 1
if abs(s1 - n) < abs(s2 - n):
	print(s1)
else:
	print(s2)


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)


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


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)


def shing():
	bop()

def bop():
	global inputis
	inputis = input()
	try:
		inputis = int(inputis)
	except:
		shing()
		return
	inputis = int(inputis)
	if 0 <= inputis <= 1000000000:
		inputis = str(inputis)
		x = inputis[len(inputis) - 1]
		inputis = int(inputis)
		x = int(x)
		if x == 0 or x == 1 or x == 2 or (x == 3) or (x == 4):
			inputis = inputis - x
		else:
			inputis = inputis + (10 - x)
		print(inputis)
	else:
		shing()
bop()


__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)


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


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 = eval(input())
n = int(n / 10 + 0.5)
print(n * 10)


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))


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


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)


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


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)


s = str(input())
if s[s.__len__() - 1] == '0':
	print(s)
	exit(0)
x = int(s)
z = int(s[s.__len__() - 1])
if z < 5:
	x = x - z
else:
	r = 10 - z
	x = x + r
print(x)


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)


x = eval(input())
if x % 10 >= 5:
	x = x + 10 - x % 10
else:
	x = x - x % 10
print(x)


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())
t = n % 10
a = min(t, 10 - t)
if a == t:
	print(n - t)
else:
	print(n + 10 - t)


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
a = int(input())
print(round(a / 10) * 10)


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()
print(round(int(s), -1))


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


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)


a = input()
if len(a) == 1:
	if int(a) >= 5:
		a = str(10)
	else:
		a = str(0)
elif int(a[len(a) - 1]) != 0:
	if int(a[len(a) - 1]) >= 5:
		a = int(a)
		for i in range(10):
			if int(str(a)[-1]) == 0:
				break
			else:
				a += 1
	else:
		a = int(a)
		for i in range(10):
			if int(str(a)[-1]) == 0:
				break
			else:
				a -= 1
print(a)


from math import ceil
n = int(input())
if n % 10 < 5:
	print(n // 10 * 10)
else:
	print(ceil(n / 10) * 10)