Harryxun/stf_run huggingface dataset:
class Dice:
    def __init__(self):
        self.omote=1
        self.sita=2
        self.migi=3
        self.ue=5
        self.hidari=4
        self.ura=6

    def North(self):
        self.omote,self.ue,self.ura,self.sita=self.sita,self.omote,self.ue,self.ura

    def East(self):
        self.omote,self.hidari,self.ura,self.migi=self.hidari,self.ura,self.migi,self.omote

    def West(self):
        self.omote,self.migi,self.ura,self.hidari=self.migi,self.ura,self.hidari,self.omote

    def South(self):
        self.omote,self.ue,self.ura,self.sita=self.ue,self.ura,self.sita,self.omote

    def Right(self):
        self.sita,self.migi,self.ue,self.hidari=self.migi,self.ue,self.hidari,self.sita

    def Left(self):
        self.sita,self.hidari,self.ue,self.migi=self.hidari,self.ue,self.migi,self.sita

n=int(input())
while(n!=0):
    sum=1
    dice=Dice()
    dice_def={"North":dice.North,"East":dice.East,"South":dice.South,"West":dice.West,"Right":dice.Right,"Left":dice.Left}
    for i in range(n):
        dice_def[input()]()
        sum+=dice.omote
    print(sum)
    n=int(input())

### FIXED CODE ###

class Dice:
    def __init__(self):
        self.omote=1
        self.sita=2
        self.migi=3
        self.ue=5
        self.hidari=4
        self.ura=6

    def North(self):
        self.omote,self.ue,self.ura,self.sita=self.sita,self.omote,self.ue,self.ura

    def East(self):
        self.omote,self.hidari,self.ura,self.migi=self.hidari,self.ura,self.migi,self.omote

    def West(self):
        self.omote,self.migi,self.ura,self.hidari=self.migi,self.ura,self.hidari,self.omote

    def South(self):
        self.omote,self.ue,self.ura,self.sita=self.ue,self.ura,self.sita,self.omote

    def Right(self):
        self.sita,self.migi,self.ue,self.hidari=self.migi,self.ue,self.hidari,self.sita

    def Left(self):
        self.sita,self.hidari,self.ue,self.migi=self.hidari,self.ue,self.migi,self.sita

n=int(input())
while(n!=0):
    sum=1
    dice=Dice()
    dice_def={"North":dice.North,"East":dice.East,"South":dice.South,"West":dice.West,"Right":dice.Right,"Left":dice.Left}
    for i in range(n):
        dice_def[input().strip()]()
        sum+=dice.omote
    print(sum)
    n=int(input())
inpl = lambda: list(map(int,input().split()))
N = int(input())
S = input()
character_pos = [set()]
ans = 0
continue_list = dict()
for i in range(N):
    s = S[i]
    new_continue_list = dict()
    cpos = character_pos[ord(s)-ord('a')]
    for p in cpos:
        new_continue_list[p] = 1
    cpos.add(i)
    for k, v in continue_list.items():
        if s == S[k+1]  and v + 1 <= i - k - 1:
            new_continue_list[k+1] = v+1
        elif v > ans:
            ans = v
    continue_list = new_continue_list

if len(continue_list.values()) > 0:
    ans = max(ans, max(continue_list.values()))
print(ans)

### FIXED CODE ###

inpl = lambda: list(map(int,input().split()))
N = int(input())
S = input()

character_pos = [ set() for _ in range(26) ]
for i in range(N):
    character_pos[ord(S[i])-ord('a')].add(i)

ans = 0
continue_list = dict()
for i in range(N):
    s = S[i]
    new_continue_list = dict()
    for p in character_pos[ord(s)-ord('a')]:
        if p < i:
            new_continue_list[p] = 1
    for k, v in continue_list.items():
        if s == S[k+1]  and v + 1 <= i - k - 1:
            new_continue_list[k+1] = v+1
        elif v > ans:
            ans = v
    continue_list = new_continue_list

if len(continue_list.values()) > 0:
    ans = max(ans, max(continue_list.values()))
print(ans)
n = int(input())
a = list(map(int, input().split()))
m = 10 ** 18

ans = 1

for i in range(0, n):
    if a[i] == 0:
        print(0)
        exit()

for i in range(0, n):
    ans *= a[i]
    if ans > m:
        print(-1)
        exit(-1)


if ans > m:
    print(-1)
else:
    print(ans)


### FIXED CODE ###

n = int(input())
a = list(map(int, input().split()))
m = 10**18

ans = 1

for i in range(0, n):
    if a[i] == 0:
        print(0)
        exit()

for i in range(0, n):
    ans *= a[i]
    if ans > m:
        print(-1)
        exit()


if ans > m:
    print(-1)
else:
    print(ans)
N,M = map(int,input().split())
A = list(map(int,input().split()))
tot_votes = sum(A)
count = 0
for a in A:
    if(a>=tot_votes/(4*M)):
        count+=1
if(count>=M):
    print("Yes")
else:
    print("No")

### FIXED CODE ###

x,y,z = input().split()
x,y = int(y),int(x)
x,z = int(z),int(x)
print(x,y,z)
if i_index >= N-1:
            break
        #print(brick_destroy)
        #print(i,end=" ")
        A_now = A[i_index :] #見つけた字の右側のみ見る

brick_destroy = N - len(brick_remain)
if brick_remain==[]:
    print(-1)
else:
    print(brick_destroy)

### FIXED CODE ###

#初期入力
import sys
N = int(input())
A=[int(i) for i in input().split()]
#


if 1 not in A:
    print(-1)
    exit
else:
    i=1 #探す数字
    brick_remain =set() #「1」は入っていること上記で確かめた
    for a in A:
        if a ==i:
            brick_remain.add(a)
            i +=1
    brick_destroy = N - len(brick_remain)       
    print(brick_destroy)
N, X = list(map(int, input().split()))
m = []
for i in N:
    m.append(i)
    
ans = len(m)

X -= sum(m)
ans += X//min(m)

### FIXED CODE ###

# -*- coding: utf-8 -*-
N, X = list(map(int, input().split()))
m = []
for i in range(N):
    m.append(int(input()))
    
ans = len(m)

X -= sum(m)
ans += X//min(m)
print(ans)
K, S = [str(x) for x in input().split()]
ans = 0
for x in range(K+1):
    for y in range(K+1):
        if S-x-y =< K:
            ans +=1
print(ans)

### FIXED CODE ###

K, S = [int(x) for x in input().split()]
ans = 0
for x in range(K+1):
    for y in range(K+1):
        a = S-x-y
        if a <= K and a >= 0:
            ans +=1
print(ans)
Q = int(input())
for i in range(Q):
    a = list(map(int,input().split()))
    a.sort()
    A = a[0]
    B = a[1]
    n = 0
    if A==B:
        n = 2*A-2
    elif B == A+1:
        n = 2*A-2
    else:
        j = 0
        while True:
            j+=1
            if j*j >= A*B:
                C = j-1
                break
        if C*(C+1)>=A*B:
            n = 2*C-2
        else:
            n = 2*C-1
    print(C)

### FIXED CODE ###

import math
Q = int(input())
for i in range(Q):
    a = list(map(int,input().split()))
    a.sort()
    A = a[0]
    B = a[1]
    n = 0
    if A==B:
        n = 2*A-2
    elif B == A+1:
        n = 2*A-2
    else:
        C = math.ceil(math.sqrt(A*B)-1)
        if C*(C+1)>=A*B:
            n = 2*C-2
        else:
            n = 2*C-1
    print(n)
A,B,C=map(int,input().split())
K=int(input())
for i in range(K):
    if A>=B:
        B=B*2
        M=K-(i+1)
    if A<B:
        break
C=C*(2**M)
if C>B and A<B:
    print('Yes')
else:
    print('No')

### FIXED CODE ###

A,B,C=map(int,input().split())
K=int(input())
M=K
for i in range(K):
    if A>=B:
        B=B*2
        M=K-(i+1)
    if A<B:
        break
C=C*(2**M)
if C>B and A<B:
    print('Yes')
else:
    print('No')
x = input()
k = input()

if int(x) <= int(k)*500:
    print("Yes")
else:
    print("No")

### FIXED CODE ###

k, x = input().split()

if int(x) <= int(k)*500:
    print("Yes")
else:
    print("No")
#!/usr/bin/env python3

#import
#import math
#import numpy as np
n = int(input())
V = list(map(int, input().split()))

even = {}
odd = {}

for i in range(n):
    v = V[i]
    if i % 2 == 0:
        if v in even:
            even[v] += 1
        else:
            even[v] = 1
    else:
        if v in odd:
            odd[v] += 1
        else:
            odd[v] = 1

odic = {0:1}
edic = {0:1}

for o in odd:
    t = odd[o]
    if t in odic:
        odic[t].append(o)
    else:
        odic[t] = [o]

for e in even:
    t = even[e]
    if t in edic:
        edic[t].append(e)
    else:
        edic[t] = [e]

okey = list(odic.keys())
ekey = list(edic.keys())


maxo = okey[-1]
maxe = ekey[-1]

ans = n - maxo - maxe

if odic[maxo] == edic[maxe]:
    if len(odic[maxo]) == 1:
        nexto = okey[-2]
        nexte = ekey[-2]
        
    ans += maxe - max(nexto, nexte)

print(ans)





### FIXED CODE ###

#!/usr/bin/env python3

#import
#import math
#import numpy as np
n = int(input())
V = list(map(int, input().split()))

even = {0:0}
odd = {0:0}

for i in range(n):
    v = V[i]
    if i % 2 == 0:
        if v in even:
            even[v] += 1
        else:
            even[v] = 1
    else:
        if v in odd:
            odd[v] += 1
        else:
            odd[v] = 1

omax = 0
emax = 0
onext = 0
enext = 0

for e in even:
    if even[e] > even[emax]:
        if even[emax] > even[enext]:
            enext = emax
        emax = e
    elif even[e] > even[enext]:
        enext = e

for o in odd:
    if odd[o] > odd[omax]:
        if odd[omax] > odd[onext]:
            onext = omax
        omax = o
    elif odd[o] > odd[onext]:
        onext = o

if omax != emax:
    print(n - even[emax] - odd[omax])
else:
    print(n - even[emax] - odd[omax] + min(even[emax] - even[enext], odd[omax] - odd[onext]))
A, B, C, D = map(lambda x: int(x), input().split())
while true:
  C -= B
  if C < 1:
    print('Yes')
    break
    A -= D
    if A < 1:
      print('No')

### FIXED CODE ###

A, B, C, D = map(lambda x: int(x), input().split())
while True:
	C -= B
	if C < 1:
		print('Yes')
		break
	A -= D
	if A < 1:
		print('No')
		break
n,m = map(int, input().split())
a = [[] for _ in range(m)]

count = 1
for i in range(m):
    p,y = map(int, input().split())
    a[p-1].append([y, count])
    count += 1
b = []
for i,j in enumerate(a):
    j_sort = sorted(j)
    for k,l in enumerate(j_sort):
        b.append([l[1],str(i+1).zfill(6)+str(k+1).zfill(6)])
        
for i in sorted(b):
    print(i[1])

### FIXED CODE ###

n, m = map(int, input().split())
D = [[] for _ in range(n)]
for i in range(m):
    p,y = map(int, input().split())
    D[p-1].append((y,i))
ans = [None] * m
for i,d in enumerate(D):
    d.sort()
    for j, (k,l) in enumerate(d):
        ans[l] = str(i+1).zfill(6) + str(j+1).zfill(6)
for i in ans:
    print(i)
import numpy as np

n = int(input())
a_array = np.array([int(elem) for elem in input().split(' ')])


def calculate_cumulative_sum(a_array, n):
    cumul_sum_array = np.zeros(n, dtype=np.int32)
    cumul_sum_array[0] = a_array[0]
    for i in range(1, n):
        cumul_sum_array[i] = cumul_sum_array[i - 1] + a_array[i]
    return cumul_sum_array


def check_1(cumul_sum_array):
    result = (cumul_sum_array != 0).all()
    return result


def check_2(cumul_sum_array):
    odd = np.sign(cumul_sum[::2])
    even = np.sign(cumul_sum[1::2])
    odd_sign = np.unique(odd)
    even_sign = np.unique(even)
    return (len(odd_sign) == 1) * (len(even_sign) == 1) * (odd_sign[0] != even_sign[0])


cumul_sum = calculate_cumulative_sum(a_array, n)
count = {'plus': 0, 'minus': 0}

def calc_num_manipulation(cumul_sum, start, n):
    cumul_sum = cumul_sum.copy()
    count = 0
    for i in range(n):
        if check_1(cumul_sum) and check_2(cumul_sum):
            break
        else:
            if i == 0:
                diff = cumul_sum[i] - start
                count += abs(diff)
                cumul_sum[i:] -= diff
            else:
                if cumul_sum[i - 1] < 0 and cumul_sum[i] <= 0:
                    diff = cumul_sum[i] - 1
                    count += abs(diff)
                    cumul_sum[i:] -= diff
                elif cumul_sum[i - 1] > 0 and cumul_sum[i] >= 0:
                    diff = cumul_sum[i] - (-1)
                    count += abs(diff)
                    cumul_sum[i:] -= diff
                else:
                    continue
    return count

count['plus'] = calc_num_manipulation(cumul_sum, 1, n)
count['minus'] = calc_num_manipulation(cumul_sum, -1, n)
print(min(count.values()))


### FIXED CODE ###

n = int(input())
a_list = list(map(int, input().split(' ')))

def count_manipulation(a_list, start):
    assert start in (0, 1)
    sum = 0
    count = 0
    for i, a in enumerate(a_list):
        sum += a
        if i % 2 == start:
            if sum > 0:
                continue
            else:
                diff = 1 - sum
                count += diff
                sum += diff
        else:
            if sum < 0:
                continue
            else:
                diff = sum - (-1)
                count += diff
                sum -= diff
    return count

count_plus = count_manipulation(a_list, 0)
count_minus = count_manipulation(a_list, 1)
print(min(count_plus, count_minus))
input()
a=list(map(int,input().split()))
print(max(a)-min(a))


### FIXED CODE ###

_=int(input())
print(_<<(_&1))
S=input()
if S==SUN:
  print(7)
if S==MON:
  print(6)
if S==TUE:
  print(5)
if S==WED:
  print(4)
if S==THU:
  print(3)
if S==FRI:
  print(2)
if S==SAT:
  print(1)
  

### FIXED CODE ###

S=input()
if S=="SUN":
  print(7)
if S=="MON":
  print(6)
if S=="TUE":
  print(5)
if S=="WED":
  print(4)
if S=="THU":
  print(3)
if S=="FRI":
  print(2)
if S=="SAT":
  print(1)
n=int(input())
a=list(map(int,input().split()))
ans=0
s=0
r=0
for l in range(n):
  while r<n and s^a[r]==s+a[r]:
    sum+=a[r]
    r+=1
  ans+=r-l
  s-=a[l]
print(ans)

### FIXED CODE ###

n=int(input())
a=list(map(int,input().split()))
ans=0
s=0
r=0
for l in range(n):
  while r<n and s^a[r]==s+a[r]:
    s+=a[r]
    r+=1
  ans+=r-l
  s-=a[l]
print(ans)
n,l=map(int,input().split())
s=sorted([input() for i in range(n)])
print(*s,sep="")


### FIXED CODE ###

a, b, c = map(int, input().split())
print("YES" if a == b == 5 and c == 7 or a == c == 5 and b == 7 or b == c == 5 and a == 7 else "NO")
K = int(input())
a, b = map(int, input().split())
ans = 'NG'
for i in range(a, b+1):
  if i % K == 0:
    ans = 'OK'
	break
print(ans)

### FIXED CODE ###

def resolve():
    K = int(input())
    a, b = map(int, input().split())
    ans = 'NG'
    for i in range(a, b + 1):
        if i % K == 0:
            ans = 'OK'
            break
    print(ans)

resolve()
from numba import njit

H, W, M = map(int, input().split())

arr = []
for _ in range(M):
    h, w = map(int, input().split())
    arr.append((h, w))


@njit
def solve(arr):
    ans = 0
    for i in range(1, H + 1):
        for j in range(1, W + 1):
            tmp = max(ans, sum([x == i or y == j for (x, y) in arr]))
            if ans < tmp:
                ans = tmp
    return ans


print(solve(arr))

### FIXED CODE ###

H, W, M = map(int, input().split())

h = [0] * H
w = [0] * W
boms = set()

for _ in range(M):
    x, y = map(int, input().split())
    h[x - 1] += 1
    w[y - 1] += 1
    boms.add((x, y))

h_max = max(h)
w_max = max(w)

h_idx = [x + 1 for x, y in enumerate(h) if y == h_max]
w_idx = [x + 1 for x, y in enumerate(w) if y == w_max]

minus = -1
for x in h_idx:
    for y in w_idx:
        if not (x, y) in boms:
            minus = 0
            break

print(h_max + w_max + minus)
from collections import deque

N, K = map(int, input().split())
x = list(map(int, input().split()))

x_upper = []

for i in reversed(x):
    if i<0:
        break
    if i>=0:
        x_upper.append(i)
        x.pop()
        
#絶対値昇順へソート
x.reverse()
x_upper.reverse()

lenXu = len(x_upper)
lenX = len(x)

if K>lenXu:
    min = K-lenXu-1
    max = lenXu-1
else:
    min = -1
    max = K-1

S = []
while min<K and min<lenX:
    if min>=0:
        if (x[min]*(-1))<x_upper[max]:
            S.append((x[min]*(-1))*2 + x_upper[max])
        else:
            S.append((x[min]*(-1)) + x_upper[max]*2)
    else:
        S.append(x_upper[max])
    min += 1
    max -= 1

print(S_stock)


### FIXED CODE ###

from collections import deque

N, K = map(int, input().split())
x = list(map(int, input().split()))

x_upper = []

for i in reversed(x):
    if i<0:
        break
    if i>=0:
        x_upper.append(i)
        x.pop()
        
#絶対値昇順へソート
x.reverse()
x_upper.reverse()

lenXu = len(x_upper)
lenX = len(x)

if K>lenXu:
    l = K-lenXu-1
    h = lenXu-1
else:
    l = -1
    h = K-1

S = []
while l<K and l<lenX:
    if h<0:
        S.append(x[l]*(-1))
    elif l<0:
        S.append(x_upper[h])
    else:
        if (x[l]*(-1))<x_upper[h]:
            S.append((x[l]*(-1))*2 + x_upper[h])
        else:
            S.append((x[l]*(-1)) + x_upper[h]*2)
    l += 1
    h -= 1

print(min(S))
def main():
    H,W=map(int,input().split())
    m=[input() for _ in range(H)]
    is_ok = True
    for h in range(H):
        for w in range(W):
            if m[w][h] == "#":
                if 0 < h-1 and m[w][h-1] == "#":
                    pass
                elif 0 < w-1 and m[w-1][h] == "#":
                    pass
                elif h+1 < H and m[w][h+1] == "#":
                    pass
                elif w+1 < W and m[w+1][h] == "#":
                    pass
                else:
                    print("No")
                    return
    print("Yes")
        
if __name__ == "__main__":
    main()

### FIXED CODE ###

def main():
    H,W=map(int,input().split())
    m=[input() for _ in range(H)]
    is_ok = True
    for h in range(H):
        for w in range(W):
            if m[h][w] == "#":
                if -1 < h-1 and m[h-1][w] == "#":
                    pass
                elif -1 < w-1 and m[h][w-1] == "#":
                    pass
                elif h+1 < H and m[h+1][w] == "#":
                    pass
                elif w+1 < W and m[h][w+1] == "#":
                    pass
                else:
                    print("No")
                    return
    print("Yes")
        
if __name__ == "__main__":
    main()
a, b, k = list(map(int,input().strip().split(' ')))

if a > k:
    a1 = a - k
    b1 = b

elif b > k - a;
    a1 = 0
    b1 = max(b -(k - a),0
    
print(a1, b1)

### FIXED CODE ###

a, b, k = list(map(int,input().strip().split(' ')))

if a > k:
    a1 = a - k
    b1 = b

else:
    a1 = 0
    b1 = max(b -(k - a),0)
    
print(a1, b1)
k = input("整数kを入力してください")
a = input("整数aを入力してください")
b = input("整数bを入力してください")
c = int(a)
d = int(b)
l = int(k)
e = d-d%l
if e>=c:
    print('ok')
else:
    print('ng')

### FIXED CODE ###

k=input()
a,b=input().split()
c=int(a)
d=int(b)
l=int(k)
e=d-d%l
if e>=c:
  print('OK')
else:
  print('NG')
n,m = map(int,input().split())
print((n*(n-1)//2))+(m*(m-1)//2))

### FIXED CODE ###

n,m = map(int,input().split())
print((n*(n-1)//2)+(m*(m-1)//2))
inp = input()
H = inp.split()[0]
W = inp.split()[1]
l = []
for i in range(H):
    l.append(input().split())

for i in range(H*2):
    line = []
    for j in range(W):
        line = line + l[(i+1)/2][j]
    print(line)


### FIXED CODE ###

inp = input()
H = int(inp.split()[0])
W = int(inp.split()[1])
l = []
for i in range(H):
    l.append(list(input()))

for i in range(H*2):
    line = ""
    for j in range(W):
        line = line + l[int((i)/2)][j]
    print(line)
n, k = map(int, input().split())
c = list(map(int, input().split()))
x = 1
for i in range(k):
  x = c[x-1]
print(x)

### FIXED CODE ###

s = input()
t = input()
u = s + t[-1]
if u == t:
  print('Yes')
else:
  print('No')
import sys
input = sys.stdin.readline
from collections import deque

h, w = map(int, input().split())
ch, cw = map(int, input().split())
gh, gw = map(int, input().split())

s = []
for i in range(h):
   s.append(input().rstrip('\n'))

INF = 10 ** 10
d = [INF] * (h*w)

A = 10**18
B = 10**9

nex = []
for i in range(-2, 3):
    for j in range(-2, 3):
        if (i, j) in [(-1,0),(1,0),(0,-1),(0,1),(0,0)]:
            continue
        else:
            nex.append((i,j))

d[(ch-1) * w + (cw-1)] = 0

T = ((-1,0), (1,0), (0,1), (0,-1))

q = [(ch-1)*A + (cw-1)*B + 0]
use = [0] * (h * w)

for x in q:
    curh = (x // A)
    x -= curh * A
    curw = (x // B)
    cnt = x - curw * B
    tmp = curh * w * curw
    if d[tmp] < cnt or use[tmp]: continue
    d[tmp] = cnt
    use[tmp] = 1

    for dh, dw in T:
        nh = curh + dh
        nw = curw + dw
        if nh >= 0 and nh < h and nw >= 0 and nw < w and s[nh][nw] == '.' and d[nh * w + nw] > cnt:
            d[nh * w + nw] = cnt
            use[nh * w + nw] = 0
            q.append(nh*A + nw*B + cnt)
    for dh, dw in nex:
        nh = curh + dh
        nw = curw + dw
        if nh >= 0 and nh < h and nw >= 0 and nw < w and s[nh][nw] == '.' and d[nh * w + nw] > cnt:
            d[nh * w + nw] = cnt + 1
            use[nh * w + nw]
            q.append(nh*A + nw*B + cnt+1)

# for item in d:
#     print(item)
gh -= 1
gw -= 1

if d[gh*w + gw] == INF:
    print(-1)
else:
    print(d[gh*w + gw])


### FIXED CODE ###

import heapq
class Dijkstra:
    INF = 10**18
    threshold = 10**9

    def __init__(self, N):
        self.MAX_V = N + 1
        self.dist = [self.INF] * self.MAX_V
        self.G = [[] for _ in range(self.MAX_V)]

    def insert(self, X, Y, cost): self.G[X].append(cost * self.threshold + Y)

    def dijkstra(self, st):
        q = []
        heapq.heappush(q, st)
        self.dist[st] = 0

        while len(q):
            p = heapq.heappop(q)
            cost = p // self.threshold
            node = p - cost * self.threshold
            if cost > self.dist[node]: continue
            for to in self.G[node]:
                to_cost = to // self.threshold
                to_node = to - to_cost * self.threshold
                to_cost += self.dist[node]
                if self.dist[to_node] > to_cost:
                    self.dist[to_node] = to_cost
                    heapq.heappush(q, to_cost * self.threshold + to_node)

h, w = map(int, input().split())
sh, sw = map(int, input().split())
eh, ew = map(int, input().split())

sh -= 1
sw -= 1
eh -= 1
ew -= 1

S = [input() for _ in range(h)]

di = Dijkstra(h*w)
for x in range(h):
    for y in range(w):
        if S[x][y] == '#': continue
        for i in range(-2, 3):
            for j in range(-2, 3):
                X = x + i
                Y = y + j
                if X < 0 or Y < 0 or X >= h or Y >= w or S[X][Y] == '#': continue
                D = abs(i) + abs(j)

                if D == 1: di.insert(x * w + y, X * w + Y, 0)
                if D >= 2: di.insert(x * w + y, X * w + Y, 1)

di.dijkstra(sh * w + sw)
ans = di.dist[eh * w + ew]
if ans == 10**18: print(-1)
else: print(ans)
import itertools
X,K,D = map(int,input().split())
lst = list(map(list, itertools.product([0, 1], repeat=K)))
ans = 10**15
for i in range(2**K):
    x = 0
    n = (lst[i].count(0))*-D
    p = (lst[i].count(1))*D
    x = abs(X + n + p)
    if x < ans:
        ans = x
print(ans)

### FIXED CODE ###

X,K,D = map(int,input().split())
X = abs(X)
ans = 0
if X - D*K> 0:
    ans = X-D*K
else:
    count = X//D
    K -= count
    X -= count*D
    if K%2 == 1:
        X = abs(X-D)
    ans = X
print(ans)