Есть 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 секунд.

Difficulty: interview

Starter code:

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:
    #print(p1, p2, at1, at2)
    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)
#print(pod_a, pod_b)
#print(et_a, et_b)
cnt = 0
if pod_a != pod_b:
    cnt += min(5 * (et_a - 1), 10 + et_a - 1)
    #print(cnt)
    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
    #print(cnt)
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
else:
    if a % (m * k) == 0:
        p1 = a // (m * k)
    else:
        p1 = a // (m * k) + 1
if (a - (p1 - 1) * m * k) < k:
    l1 = 1
else:
    if (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
else:
    if b % (m * k) == 0:
        p2 = b // (m * k)
    else:
        p2 = b // (m * k) + 1
if (b - (p2 - 1) * m * k) < k:
    l2 = 1
else:
    if (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)