Есть n-подъездный дом, в каждом подъезде по m этажей, и на каждом этаже каждого подъезда ровно k квартир. Таким образом, в доме всего n·m·k квартир. Они пронумерованы естественным образом от 1 до n·m·k, то есть первая квартира на первом этаже в первом подъезде имеет номер 1, первая квартира на втором этаже первого подъезда имеет номер k + 1 и так далее. Особенность этого дома состоит в том, что он круглый. То есть если обходить его по часовой стрелке, то после подъезда номер 1 следует подъезд номер 2, затем подъезд номер 3 и так далее до подъезда номер n. После подъезда номер n снова идёт подъезд номер 1.

Эдвард живёт в квартире номер a, а Наташа — в квартире номер b. Переход на 1 этаж вверх или вниз по лестнице занимает 5 секунд, переход от двери подъезда к двери соседнего подъезда — 15 секунд, а переход в пределах одного этажа одного подъезда происходит мгновенно. Также в каждом подъезде дома есть лифт. Он устроен следующим образом: он всегда приезжает ровно через 10 секунд после вызова, а чтобы переместить пассажира на один этаж вверх или вниз, лифт тратит ровно 1 секунду. Посадка и высадка происходят мгновенно.

Помогите Эдварду найти минимальное время, за которое он сможет добраться до квартиры Наташи. Считайте, что Эдвард может выйти из подъезда только с первого этажа соответствующего подъезда (это происходит мгновенно). Если Эдвард стоит перед дверью какого-то подъезда, он может зайти в него и сразу окажется на первом этаже этого подъезда (это также происходит мгновенно). Эдвард может выбирать, в каком направлении идти вокруг дома.


-----Входные данные-----

В первой строке входных данных следуют три числа n, m, k (1 ≤ n, m, k ≤ 1000) — количество подъездов в доме, количество этажей в каждом подъезде и количество квартир на каждом этаже каждого подъезда соответственно.

Во второй строке входных данных записаны два числа a и b (1 ≤ a, b ≤ n·m·k) — номера квартир, в которых живут Эдвард и Наташа, соответственно. Гарантируется, что эти номера различны. 


-----Выходные данные-----

Выведите единственное целое число — минимальное время (в секундах), за которое Эдвард сможет добраться от своей квартиры до квартиры Наташи.


-----Примеры-----
Входные данные
4 10 5
200 6

Выходные данные
39

Входные данные
3 1 5
7 2

Выходные данные
15



-----Примечание-----

В первом тестовом примере Эдвард находится в 4 подъезде на 10 этаже, а Наташа находится в 1 подъезде на 2 этаже. Поэтому Эдварду выгодно сначала спуститься на лифте на первый этаж (на это он потратит 19 секунд, из которых 10 — на ожидание и 9 — на поездку на лифте), затем обойти дом против часовой стрелки до подъезда номер 1 (на это он потратит 15 секунд), и наконец подняться по лестнице на этаж номер 2 (на это он потратит 5 секунд). Таким образом, ответ равен 19 + 15 + 5 = 39.

Во втором тестовом примере Эдвард живёт в подъезде 2 на этаже 1, а Наташа находится в подъезде 1 на этаже 1. Поэтому Эдварду выгодно просто обойти дом по часовой стрелке до подъезда 1, на это он потратит 15 секунд.

Source: codeforces | Difficulty: MEDIUM


Solutions:
(n, m, k) = map(int, input().split())
(a, b) = map(int, input().split())
a -= 1
b -= 1

def p(x):
	return x // (m * k)

def e(x):
	return (x - p(x) * m * k) // k

def lift(x):
	return min(5 * x, 10 + x)
if p(a) == p(b):
	dif = abs(e(a) - e(b))
	print(lift(dif))
else:
	print(lift(e(a)) + 15 * min((p(a) - p(b) + n) % n, (p(b) - p(a) + n) % n) + lift(e(b)))


read = lambda : list(map(int, input().split()))
(n, m, k) = read()
(a, b) = read()
pa = (a - 1) // (m * k) + 1
fa = (a - 1) % (m * k) // k + 1
pb = (b - 1) // (m * k) + 1
fb = (b - 1) % (m * k) // k + 1
Tp = min(abs(pa - pb), abs(pa - pb + n), abs(pb - pa + n)) * 15
if pa == pb:
	Tf = min(abs(fa - fb) * 5, abs(fa - fb) + 10)
else:
	cnt1 = min((fa - 1) * 5, fa - 1 + 10)
	cnt2 = min((fb - 1) * 5, fb - 1 + 10)
	Tf = cnt1 + cnt2
ans = Tp + Tf
print(ans)


import sys, math

def numb(ch):
	pod = ch // (m * k)
	if ch % (m * k) != 0:
		pod += 1
	et = ((ch - 1) % (m * k) + 1) // k
	if ((ch - 1) % (m * k) + 1) % k != 0:
		et += 1
	return (pod, et)
ans = 0
(n, m, k) = map(int, input().split())
(a, b) = map(int, input().split())
ans = 0
(f_x, f_y) = numb(a)
(a_x, a_y) = numb(b)
if f_x != a_x:
	z = min(math.fabs(f_x - a_x), math.fabs(n - max(f_x, a_x) + min(f_x, a_x)))
	ans += 15 * z
	ans += min(10 + f_y - 1, (f_y - 1) * 5)
	ans += min(10 + a_y - 1, (a_y - 1) * 5)
	print(int(ans))
else:
	ans += min(10 + math.fabs(a_y - f_y), math.fabs(a_y - f_y) * 5)
	print(int(ans))


(n, m, k) = map(int, input().split())
(kv1, kv2) = map(int, input().split())
kv1 -= 1
kv2 -= 1
p1 = kv1 // (m * k)
p2 = kv2 // (m * k)
kv1 %= k * m
kv2 %= k * m
at1 = kv1 // k
at2 = kv2 // k
if p1 == p2:
	print(min(10 + abs(at1 - at2), 5 * abs(at1 - at2)))
else:
	res = 15 * min(abs(p1 - p2), min(p1, p2) + n - max(p1, p2))
	res += min(10 + at1, at1 * 5)
	res += min(10 + at2, at2 * 5)
	print(res)


from math import *
(n, m, k) = list(map(int, input().split()))
(a, b) = list(map(int, input().split()))
pod_a = ceil(a / (m * k))
pod_b = ceil(b / (m * k))
aa = a % (m * k)
if aa == 0:
	aa = m * k
bb = b % (m * k)
if bb == 0:
	bb = m * k
et_a = ceil(aa / k)
et_b = ceil(bb / k)
cnt = 0
if pod_a != pod_b:
	cnt += min(5 * (et_a - 1), 10 + et_a - 1)
	et_a = 1
	if pod_a > pod_b:
		(pod_b, pod_a) = (pod_a, pod_b)
	cnt += min(pod_b - pod_a, n - (pod_b - pod_a)) * 15
cnt += min(5 * abs(et_a - et_b), 10 + abs(et_a - et_b))
print(cnt)


def f(a, b):
	return min(abs(a - b) * 5, abs(a - b) + 10)

def main():
	(n, m, k) = map(int, input().split())
	(a, b) = map(int, input().split())
	(pa, pb) = ((a - 1) // (m * k), (b - 1) // (m * k))
	ans = min((pa - pb + n) % n, (-pa + pb + n) % n) * 15
	(ea, eb) = ((a - 1) // k % m, (b - 1) // k % m)
	if ans == 0:
		ans = f(ea, eb)
	else:
		ans += f(ea, 0) + f(eb, 0)
	print(ans)
main()


(n, m, k) = map(int, input().split())
(a, b) = map(int, input().split())
a -= 1
b -= 1
an = a // (m * k)
am = a % (m * k) // k
bn = b // (m * k)
bm = b % (m * k) // k
res = 0
n -= 1
if an != bn:
	res = res + min(10 + bm, bm * 5) + min(10 + am, am * 5)
	if an < bn:
		res = res + min(bn - an, n - bn + an + 1) * 15
	else:
		res = res + min(an - bn, bn + n - an + 1) * 15
else:
	x = abs(bm - am)
	res = res + min(10 + x, x * 5)
print(res)


import math
(n, m, k) = list(map(int, input().split()))
(a, b) = list(map(int, input().split()))
p1 = math.ceil(a / (m * k))
e1 = math.ceil((a - (p1 - 1) * (m * k)) / k)
if e1 == 0:
	e1 = m
p2 = math.ceil(b / (m * k))
e2 = math.ceil((b - (p2 - 1) * (m * k)) / k)
if e2 == 0:
	e2 = m
ans = 0
if p1 == p2:
	ans = min(abs(e1 - e2) + 10, abs(e1 - e2) * 5)
else:
	ans = min(e1 - 1 + 10, (e1 - 1) * 5) + min((p1 - p2) % n, (p2 - p1) % n) * 15 + min(e2 - 1 + 10, (e2 - 1) * 5)
print(ans)


from math import *
(n, m, k) = map(int, input().split())
(a, b) = map(int, input().split())
a -= 1
b -= 1
(poda, podb) = (a // (m * k), b // (m * k))
(levela, levelb) = (a % (m * k) // k, b % (m * k) // k)
timepod = min(abs(poda - podb), n - abs(poda - podb)) * 15
if poda == podb:
	if levela == levelb:
		print(0)
	else:
		print(min(abs(levela - levelb) * 5, 10 + abs(levela - levelb)))
else:
	print(timepod + min(10 + levela, levela * 5) + min(10 + levelb, levelb * 5))


(n, m, k) = list(map(int, input().split()))
(a, b) = list(map(int, input().split()))
podE = a // (m * k)
if a % (m * k) != 0:
	podE += 1
podN = b // (m * k)
if b % (m * k) != 0:
	podN += 1
etE = a % (m * k) // k
if a % (m * k) % k != 0:
	etE += 1
etN = b % (m * k) // k
if b % (m * k) % k != 0:
	etN += 1
if podE == 0:
	podE = n
if etE == 0:
	etE = m
if podN == 0:
	podN = n
if etN == 0:
	etN = m
if podE == podN and etE == etN:
	print(0)
elif podE == podN:
	print(min(abs(etE - etN) * 5, 10 + abs(etE - etN)))
else:
	down = min((etE - 1) * 5, 10 + (etE - 1))
	move = min(abs(podE - podN), n - max(podN, podE) + min(podE, podN)) * 15
	up = min((etN - 1) * 5, 10 + (etN - 1))
	print(down + move + up)


[n, m, k] = [int(i) for i in input().split()]
[n1, n2] = [int(i) for i in input().split()]
e1 = 0
e2 = 0
p1 = n1 // (m * k)
if p1 * m * k != n1:
	p1 += 1
else:
	e1 = m
p2 = n2 // (m * k)
if p2 * m * k != n2:
	p2 += 1
else:
	e2 = m
t = 0
t += min(abs(p2 - p1), min(p2 + abs(n - p1), p1 + abs(n - p2))) * 15
if e1 == 0:
	e1 = n1 % (m * k) // k
	if n1 % k != 0:
		e1 += 1
if e2 == 0:
	e2 = n2 % (m * k) // k
	if n2 % k != 0:
		e2 += 1
if p1 != p2:
	if e1 < 4:
		t += (e1 - 1) * 5
	if e2 < 4:
		t += (e2 - 1) * 5
	if e1 >= 4:
		t += 10 + e1 - 1
	if e2 >= 4:
		t += 10 + e2 - 1
else:
	e = abs(e1 - e2)
	if e < 3:
		t += e * 5
	if e >= 3:
		t += 10 + e
print(t)


(n, m, k) = list(map(int, input().split()))
(a, b) = list(map(int, input().split()))
p = []
for i in range(1, n + 1):
	p.append(i * m * k)
it = [[0] * n for i in range(m)]
for i in range(m):
	for j in range(n):
		it[i][j] = j * m * k + k * (i + 1)
fl1 = True
fl2 = True
for i in range(n):
	for j in range(m):
		if it[j][i] - a >= 0 and fl1:
			p1 = i + 1
			it1 = j + 1
			fl1 = False
		if it[j][i] - b >= 0 and fl2:
			p2 = i + 1
			it2 = j + 1
			fl2 = False
		if not fl1 and (not fl2):
			break
if p1 != p2:
	t1 = min(it1 - 1 + 10, 5 * (it1 - 1))
	if p1 > p2:
		s1 = p1
		t21 = 0
		while s1 != p2:
			s1 += 1
			t21 += 1
			if s1 > n:
				s1 //= n
	else:
		s1 = p2
		t21 = 0
		while s1 != p1:
			s1 += 1
			t21 += 1
			if s1 > n:
				s1 //= n
	t21 *= 15
	t2 = min(t21, abs(p2 - p1) * 15)
	t3 = min(it2 - 1 + 10, 5 * (it2 - 1))
	t = t1 + t2 + t3
	print(t)
else:
	t = min(abs(it2 - it1) * 5, 10 + abs(it2 - it1))
	print(t)


x = list(map(int, input().split()))
(a, b) = list(map(int, input().split()))
n = x[0]
m = x[1]
k = x[2]
l1 = 0
p1 = 0
l2 = 0
p2 = 0
t = 0
if a < m * k:
	p1 = 1
elif a % (m * k) == 0:
	p1 = a // (m * k)
else:
	p1 = a // (m * k) + 1
if a - (p1 - 1) * m * k < k:
	l1 = 1
elif (a - (p1 - 1) * m * k) % k == 0:
	l1 = (a - (p1 - 1) * m * k) // k
else:
	l1 = (a - (p1 - 1) * m * k) // k + 1
if b < m * k:
	p2 = 1
elif b % (m * k) == 0:
	p2 = b // (m * k)
else:
	p2 = b // (m * k) + 1
if b - (p2 - 1) * m * k < k:
	l2 = 1
elif (b - (p2 - 1) * m * k) % k == 0:
	l2 = (b - (p2 - 1) * m * k) // k
else:
	l2 = (b - (p2 - 1) * m * k) // k + 1
if p1 == p2:
	if l1 == l2:
		t = 0
	else:
		t = min(abs(l1 - l2) + 10, abs(l1 - l2) * 5)
else:
	if l1 > 1:
		t = min((l1 - 1) * 5, l1 + 10 - 1)
	else:
		t = 0
	t += 15 * min(abs(p1 - p2), n - max(p1, p2) + min(p1, p2))
	if l2 > 1:
		t += min(10 + l2 - 1, (l2 - 1) * 5)
print(t)