ZhenlongDai/ACPR huggingface dataset:
Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int, input().split())
x = max(b - a - w, 0)
y = max(a - b - w, 0)
print(min(x, y))

Failing test case input:
-1 -2 7

Expected output:
10


Actual output:
0


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())
print(max(a - b - w, b - a - w, 0))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b = map(int,input().split())
print(min(abs(a-b-w),abs(b-a-w),abs(a-b)))

Failing test case input:
-1 -38 1

Expected output:
40


Actual output:
38


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
print(max(abs(a-b)-w,0))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b = map(int,input().split())
c = min(a,b)
d = max(a,b)
if c + w >= d:
  print(0)
else:
  print(c+w-d)

Failing test case input:
0 -1 110

Expected output:
111


Actual output:
-111


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
c = min(a,b)
d = max(a,b)
if c + w >= d:
  print(0)
else:
  print(d-c-w)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b = map(int,input().split())

if a+w == b:
  print(0)
elif a+w < b:
  print(b-(a+w))
elif a < b and b < a+w:
  print(0)
elif a == b:
  print(0)

Failing test case input:
8 10 1

Expected output:
1


Actual output:

Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())

if a+w < b:
  print(abs(b-(a+w)))
elif b+w < a:
  print(abs(a-(b+w)))
else:
  print(0)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W, a, b = (int(i) for i in input().split())

if a<b:
    print( max(b-W-a, 0))
else:
    print( max(a-W-a, 0))

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
W, a, b = (int(i) for i in input().split())

if a<b:
    print( max(b-W-a, 0))
else:
    print( max(a-W-b, 0))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def inpl(): return list(map(int, input().split()))
W, a, b = inpl()
if b-W-a>0:
    print(b-W-a)
else:
    print(0)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
def inpl(): return list(map(int, input().split()))
W, a, b = inpl()
if max(a, b)-W-min(a, b)>0:
    print(max(a, b)-W-min(a, b))
else:
    print(0)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b =[int(i) for i in input().split()]
if(b+w>=a):
    if(b>a):
        if(a+w>=b):
            print(0)
        else:
            print((a+w)-b)
    else:
        print(0)
else:
    print(a-(b+w))

Failing test case input:
0 -1 61

Expected output:
62


Actual output:
-62


Fixed submission (verdict: Accepted):
w,a,b =[int(i) for i in input().split()]
if(b+w>=a):
    if(b>a):
        if(a+w>=b):
            print(0)
        else:
            print(b-(a+w))
    else:
        print(0)
else:
    print(a-(b+w))
Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
W,a,b =map(int,input().split())
if b-(a+W)<0:
    print(0)

elif b<a:
    print(a-(b+W))
else:
    print(b-(a+W))

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
W,a,b =map(int,input().split())
if b>=a:
    if b-(a+W)<0:print(0)
    else:print(b-(a+W))
else :
    if a-(b+W)<0:print(0)
    else:print(a-(b+W))

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if len(sorted(set(range(a,a+w+1)) | set(range(b,b+w+1)))) ==0:
  print("0")
elif b>=a+w:
  print(b-a-w)
elif a>=b+w:
  print(a-b-w)

Failing test case input:
-2 -1 111

Expected output:
114


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if len(sorted(set(range(a,a+w+1)) & set(range(b,b+w+1)))) !=0:
  print("0")
elif b>=a+w:
  print(b-a-w)
elif a>=b+w:
  print(a-b-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int, input().split())
if a <= b <= a + w or a - w <= b < a:
    print(0)
elif not a < b < a + w:
    print(b - a - w)
else:
    print(a - b - w)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
-17


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())
if a <= b <= a + w or a - w <= b < a:
    print(0)
elif a + w < b:
    print(b - a - w)
else:
    print(a - b - w)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if len(sorted(set(range(a,a+w+1)) | set(range(b,b+w+1)))) ==0:
  print("0")
else:
  print(min(abs(b-a-w),abs(a-b-w)))

Failing test case input:
-1 -62 2

Expected output:
65


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if len(sorted(set(range(a,a+w+1)) & set(range(b,b+w+1)))) !=0:
  print("0")
elif b>=a+w:
  print(b-a-w)
elif a>=b+w:
  print(a-b-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b = map(int, input().split())
if a==b:
  print(0)
elif min(a,b)+w >= max(a,b):
  print(0)
elif min(a,b)+w < max(a,b):
  print(max(a,b)-min(a,b)+w)


Failing test case input:
1 0 98

Expected output:
97


Actual output:
99


Fixed submission (verdict: Accepted):
w,a,b = map(int, input().split())
if a==b:
  print(0)
elif min(a,b)+w >= max(a,b):
  print(0)
elif min(a,b)+w < max(a,b):
  print(max(a,b)-min(a,b)-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if min(a,b) + w >= max(a,b):
  print(0)
else:
  ans = max(a,b) - min(a,b) + w
  print(ans)

Failing test case input:
2 -91 -1

Expected output:
88


Actual output:
92


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if min(a,b) + w >= max(a,b):
  print(0)
else:
  ans = max(a,b) - min(a,b) - w
  print(ans)
Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W,a,b=map(int,input().split())
print(min(max(W+a - b,0),max(a-W-b,0)))


Failing test case input:
0 1 18

Expected output:
17


Actual output:
0


Fixed submission (verdict: Accepted):
W,a,b=map(int,input().split())
print(max(max(0,b-W-a),max(0,a-W-b)))

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
if b<=c:
  if a+b>=c:
    print(0)
  else:
    print(c-b)
else:
  if a+c>=b:
    print(0)
  else:
    print(b-c)

Failing test case input:
1 -47 0

Expected output:
46


Actual output:
47


Fixed submission (verdict: Accepted):
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
if b<=c:
  if a+b>=c:
    print(0)
  else:
    print(c-b-a)
else:
  if a+c>=b:
    print(0)
  else:
    print(b-c-a)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if a>b:
  t=a
  a=b
  b=t
if b-a<abs(b-a-w)+1:
  print(b-a)
else:
  print(abs(b-a-w)+1)


Failing test case input:
-1 -1 7

Expected output:
9


Actual output:
8


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if a>b:
  t=a
  a=b
  b=t
if a<=b<=a+w:
  print(0)
else:
  print(b-a-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
def main():
    x = input().split()

    W = int(x[0])
    a = int(x[1])
    b = int(x[2])

    if a+W > b or a < b+W:
        print(0)
        return

    l = [a,a+W,b,b+W]
    l.remove(min(l))
    l.remove(max(l))
    print(max(l) - min(l))

if __name__ == '__main__':
    main()

Failing test case input:
-4 -19 -1

Expected output:
22


Actual output:
0


Fixed submission (verdict: Accepted):
def main():
    x = input().split()

    W = int(x[0])
    a = int(x[1])
    b = int(x[2])

    if b > a+W:
        print(b - (a+W))
        return
    elif a > b+W:
        print(a - (b+W))
        return

    print(0)

if __name__ == '__main__':
    main()

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b = map(int,input().split())
aw = a+w
bw =b+w
print(min(abs(b-aw),abs(bw-a)))

Failing test case input:
-1 -1 100

Expected output:
102


Actual output:
100


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
aw = a+w
bw =b+w
print(max(0,a-bw,b-aw))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if a+w<b:
    print(b-a-w)
else:
    print(0)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if a>b+w:
    print(a-b-w)
elif a+w>b:
    print(0)
else:
    print(b-a-w)

Problem: p03778
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
a,b,c=map(int,input().split())
print(min(abs(a-b),abs(a-c)))

Failing test case input:
0 -1 61

Expected output:
62


Actual output:
1


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
print(max(0,abs(a-b)-w))
Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int, input().split())

if a+w < b:
  print(b-a-w)
else:
  print(0)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())
 
if a+w < b:
  print(b-a-w)
elif b+w < a:
  print(a-b-w)
else:
  print(0)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if a >= b:
        print(a-b)
elif a+w>=b:
    print('0')
else:
    print(b-a-w)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
9


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if b>=a+w:
    print(b-a-w)
else:
    if b+w>=a:
        print('0')
    else:
        print(a-b-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W,a,b=map(int,input().split())

print(min(b-a,1+b-(a+W)))




Failing test case input:
-1 -30 2

Expected output:
33


Actual output:
32


Fixed submission (verdict: Accepted):
W,a,b=map(int,input().split())

a,b=min(a,b),max(a,b)

print(max(0,b-a-W))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b = map(int, input().split())

ans = min(abs(b - (a + w)), abs(a - (b + w)))
if ans < 0:
	print(0)
else:
	print(ans)

Failing test case input:
-1 -40 1

Expected output:
42


Actual output:
40


Fixed submission (verdict: Accepted):
w,a,b = map(int, input().split())

if abs(a - b) <= w:
	print(0)
else:
	print(abs(a - b) - w)

Problem: p03778
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
w, a, b = map(int, input().split())

if w >= abs(a-b):
    print(0)
elif a > b:
    print(w-b)
elif b > a:
    print(w-a)

Failing test case input:
3 -24 -2

Expected output:
19


Actual output:
27


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())

if w >= abs(a-b):
    print(0)
else:
    if a > b:
        print(a-(b+w))
    else:
        print(b-(a+w))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int,input().split())
if abs(b - a- w) >= abs(a - b):
    print(abs(a-b))
elif a <= b <= a+w or b <= a <= b+w:
    print(0)
else:
    print(abs(b - a - w))


Failing test case input:
-1 -1 101

Expected output:
103


Actual output:
102


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
if a <= b <= a+w or a <= b <= a+w:
    print(0)
elif a+w < b:
    print(b-a-w)
else:
    print(a-b-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int, input().split())
if a < b:
  print(max(0, a+w-b))
else:
  print(max(0, b+w-a))

Failing test case input:
1 -24 -2

Expected output:
21


Actual output:
0


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())
if a+w < b:
  print(b-a-w)
elif b+w < a:
  print(a-b-w)
else:
  print(0)
Problem: p03778
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):



def main():
    a, b , c = map(int, input().split())
    print(max(b - a - 1, 0))







if __name__ == '__main__':
    main()

Failing test case input:
3 -91 -1

Expected output:
87


Actual output:
0


Fixed submission (verdict: Accepted):


def main():
    w, a, b = map(int, input().split())
    a, b = min(a, b), max(a, b)
    print(max(b - a - w, 0))







if __name__ == '__main__':
    main()

Problem: p03778
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
w,a,b=map(int,input().split())
aa=w+a
bb=w+b
if a<=bb or b<=aa:
  print(0)
elif bb<a and aa>b:
  print(a-bb)
else:print(b-aa)

Failing test case input:
0 -16 2

Expected output:
18


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
aa=w+a
bb=w+b
if (b<=aa and a<=bb) or (a<=bb and b<=aa):
    print(0)
else:print(max(b-aa,a-bb))

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if w+a >= b:
    print('0')

else:
    if b<=a:
        print(a-b)
    else:
        print(b-a-w)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if b>=a+w:
    print(b-a-w)
else:
    if b+w>=a:
        print('0')
    else:
        print(a-b-w)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b = map(int,input().split())

if a+w == b:
  print(w)
elif a+w < b:
  print(b-(a+w))
elif a+w >= b:
  print(0)
elif a == b:
  print(0)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())

if a+w < b:
  print(abs(b-(a+w)))
elif b+w < a:
  print(abs(a-(b+w)))
else:
  print(0)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if a<=b+w or b<=a+w:
    print(0)
else:
    print(abs(a+w-b))

Failing test case input:
1 2 18

Expected output:
15


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if a+w<b:
    print(b-(a+w))
elif b+w<a:
    print(a-(b+w))
else:
    print(0)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
w,a,b = map(int, input().split())
if a+w>b or b+w>a:
  print(0)
elif a+w<b:
  print(b-a-w+1)
elif b+w<a:
  print(a-b-w+1)

Failing test case input:
0 -273 0

Expected output:
273


Actual output:
0


Fixed submission (verdict: Accepted):
import sys
w,a,b = map(int, input().split())
if a+w>=b>=a or b+w>=a>=b:
  print(0)
elif a+w<b:
  print(b-a-w)
elif b+w<a:
  print(a-b-w)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W, a, b = map(int, input().split())
print(max(0, max(a, b) - min(a, b)+W))

Failing test case input:
2 -61 -1

Expected output:
58


Actual output:
62


Fixed submission (verdict: Accepted):
W, a, b = map(int, input().split())
print(max(0, max(a, b) - (min(a, b) + W)))
Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W, a, b = map(int, input().split())
print(max(min(a - b - W, a - b + W), 0))

Failing test case input:
-1 -1 111

Expected output:
113


Actual output:
0


Fixed submission (verdict: Accepted):
W, a, b = map(int, input().split())
print(max(max(a, b) - (min(a, b) + W), 0))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int, input().split())
if a < b < a + w or a - w < b < a:
    print(0)
elif not a < b < a + w:
    print(b - a - w)
else:
    print(a - b - w)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
-17


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())
if a <= b <= a + w or a - w <= b < a:
    print(0)
elif a + w < b:
    print(b - a - w)
else:
    print(a - b - w)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b=map(int,input().split())
if len(sorted(set(range(a,a+w+1)) | set(range(b,b+w+1)))) !=0:
  print("0")
elif b>=a+w:
  print(b-a-w)
elif a>=b+w:
  print(a-b-w)

Failing test case input:
0 -16 2

Expected output:
18


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b=map(int,input().split())
if len(sorted(set(range(a,a+w+1)) & set(range(b,b+w+1)))) !=0:
  print("0")
elif b>=a+w:
  print(b-a-w)
elif a>=b+w:
  print(a-b-w)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
W, a, b = map(int,input().split())
if b > a+W:
    print(b-(a+W))
elif b <= a+W and b+W >= a:
    print(0)
else:
    print(b+W-a)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
-1


Fixed submission (verdict: Accepted):
W, a, b = map(int,input().split())
if b > a+W:
    print(abs(b-(a+W)))
elif b <= a+W and b+W >= a:
    print(0)
else:
    print(abs(b+W-a))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b = map(int,input().split())
print(0 if  abs(a-b)-w <= w else abs(a-b)-w)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
print(0 if abs(a-b) <= w else abs(a-b)-w)

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w,a,b = map(int,input().split())
aw = a+w
bw =b+w
print(min(abs(a-b),abs(b-aw),abs(bw-a),abs(bw-aw)))

Failing test case input:
-4 -19 -1

Expected output:
22


Actual output:
14


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
aw = a+w
bw =b+w
print(max(0,a-bw,b-aw))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W,a,b = map(int,input().split())
A = min(a,b)
B = max(a,b)
print(A,B)
if B-A >= W:
	ans = B-A-W
else:
	ans = 0
print(ans)

Failing test case input:
0 -273 -1

Expected output:
272


Actual output:
-273 -1
272


Fixed submission (verdict: Accepted):
W,a,b = map(int,input().split())
A = min(a,b)
B = max(a,b)

if B-A >= W:
	ans = B-A-W
else:
	ans = 0
print(ans)
Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w, a, b = map(int, input().split())

if a + w < b:
  ans = b - (a + w)
elif a > b + w:
  ans = a - (b + w)
else:
  ans = 0

Failing test case input:
3 -88 -1

Expected output:
84


Actual output:

Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())

if a + w < b:
  ans = b - (a + w)
elif a > b + w:
  ans = a - (b + w)
else:
  ans = 0
  
print(ans)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W,a,b = map(int,input().split())

if a+W < b:
    print(b-(a+W))
elif b+W < a:
    print(b+W-a)
else:
    print(0)


Failing test case input:
8 10 1

Expected output:
1


Actual output:
-1


Fixed submission (verdict: Accepted):
W,a,b = map(int,input().split())

if a+W < b:
    print(b-(a+W))
elif b+W < a:
    print(a-(b+W))
else:
    print(0)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W, a, b = map(int, input().split())
m = min(a, b)
M = max(a, b)
print(max(M-m-2*W, 0))

Failing test case input:
2 -88 -1

Expected output:
85


Actual output:
83


Fixed submission (verdict: Accepted):
W, a, b = map(int, input().split())
m = min(a, b)
M = max(a, b)
print(max(M-m-W, 0))

Problem: p03778
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
w, a, b = map(int, input().split())
if a <= b:
    print(b - w + a if b - w + a > 0 else 0)
else :
    print(a - w + b if a - w + a > 0 else 0)

Failing test case input:
-1 -37 -1

Expected output:
37


Actual output:
0


Fixed submission (verdict: Accepted):
w, a, b = map(int, input().split())
if a <= b:
    print(b - w - a if b - w - a > 0 else 0)
else :
    print(a - w - b if a - w - b > 0 else 0)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W,A,B = map(int,input().split())
if W+A>=B:
	print(0)
else:
	print(B-A-W)

Failing test case input:
8 10 1

Expected output:
1


Actual output:
0


Fixed submission (verdict: Accepted):
W,A,B = map(int,input().split())
if W+A>=B:
	if B+W<=A:
		print(A-W-B)
	else:
		print(0)
else:
	print(B-A-W)

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
w,a,b = map(int,input().split())
print(max(min(a,b)-max(a,b)-w,0))

Failing test case input:
-1 -1 139

Expected output:
141


Actual output:
0


Fixed submission (verdict: Accepted):
w,a,b = map(int,input().split())
print(max(max(a,b)-min(a,b)-w,0))

Problem: p03778
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
W,a,b = map(int,input().split())

if a+W < b:
    print(abs(b-a+W))
elif b+W < a:
    print(abs(b+W-a))
else:
    print(0)

Failing test case input:
-1 -24 1

Expected output:
26


Actual output:
24


Fixed submission (verdict: Accepted):
W,a,b = map(int,input().split())

if a+W < b:
    print(abs(a+W-b))
elif b+W < a:
    print(abs(b+W-a))
else:
    print(0)
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,T=map(int,input().split())
print(B*(T%A))


Failing test case input:
10 16 1

Expected output:
0


Actual output:
16


Fixed submission (verdict: Accepted):
A,B,T=map(int,input().split())
print(B*(T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
ans = ((t - t%a)/a)*b
print(ans)

Failing test case input:
4 -1 17

Expected output:
-4


Actual output:
-4.0


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
ans = ((t - t%a)/a)*b
print(int(ans))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
A, B, T = map(int, input().split())

print(int(math.floor(T / A) + B))

Failing test case input:
38 2 -1

Expected output:
-2


Actual output:
1


Fixed submission (verdict: Accepted):
import math
A, B, T = map(int, input().split())

print(int(math.floor(T / A) * B))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,T = map(int, input().split())
print(T/A*B)

Failing test case input:
1 -8 19

Expected output:
-152


Actual output:
-152.0


Fixed submission (verdict: Accepted):
A,B,T = map(int, input().split())
print(T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=map(int,input().split())
print(((C+0.5)%A)*B)

Failing test case input:
17 -1 8

Expected output:
0


Actual output:
-8.5


Fixed submission (verdict: Accepted):
A,B,C=map(int,input().split())
print(int(((C+0.5)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, T = map(int, input().split())
print(A*B*T)

Failing test case input:
3 10 11

Expected output:
30


Actual output:
330


Fixed submission (verdict: Accepted):
A, B, T = map(int, input().split())
print(B*(T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
T = t + 0.5

print(round(T/a)*b)

Failing test case input:
3 11 -16

Expected output:
-66


Actual output:
-55


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
T = t + 0.5

print(round(T
Problem: p03059
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,t=I()
if a > t:
    print(0)
    sys.exit()
time=0
cnt=1
while t+0.5 > time:
    ans +=b
    time+=a*cnt
    cnt+=1

print(ans)


Failing test case input:
1 -14 1

Expected output:
-14


Actual output:
-28


Fixed submission (verdict: Accepted):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,t=I()


print(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A ,B ,T = map(int, input().split()) 
print(T/A*B)

Failing test case input:
2 43 4

Expected output:
86


Actual output:
86.0


Fixed submission (verdict: Accepted):
A ,B ,T = map(int, input().split()) 
print((T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t=map(int,input().split())
t=t/a
print(b*t)

Failing test case input:
2 -3 10

Expected output:
-15


Actual output:
-15.0


Fixed submission (verdict: Accepted):
a,b,t=map(int,input().split())
print(b*(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
print(round((t+0.5)/a)*b)

Failing test case input:
7 38 40

Expected output:
190


Actual output:
228


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int,input().split())
if(c<a):
    print('0')
else:
    print(round(c/a)*b)

Failing test case input:
2 9 -4

Expected output:
-18


Actual output:
0


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
if(c<a):
    print('0')
else:
    print((c

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t=map(int,input().split())
print(b*(t%a))

Failing test case input:
12 20 8

Expected output:
0


Actual output:
160


Fixed submission (verdict: Accepted):
a,b,t=map(int,input().split())
print(b*(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
c =(t+0.5)
print(c*b)

Failing test case input:
1 -7 21

Expected output:
-147


Actual output:
-150.5


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print((t
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
s = input().split()

A=int(s[0])
B=int(s[1])
C=int(s[2])

tmp=C/A + 0.5
if A > C:
  answer = 0
else:
  answer = math.floor(tmp) *B
print(answer)

Failing test case input:
3 5 11

Expected output:
15


Actual output:
20


Fixed submission (verdict: Accepted):
import math
s = input().split()

A=int(s[0])
B=int(s[1])
C=int(s[2])

tmp=C/A
answer = math.floor(tmp) *B
print(answer)

Problem: p03059
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
a,b,t=map(int,input().split())
aa=(t+0.5)
print(b*aa)

Failing test case input:
17 0 4

Expected output:
0


Actual output:
0.0


Fixed submission (verdict: Accepted):
a,b,t=map(int,input().split())
aa=int((t+0.5)
print(b*aa)

Problem: p03059
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import sys


def parse(file):
    a, b, t = map(int, file.readline().split())
    return a, b, t


def main(a, b, t):
    k = 0
    while (k + 1) * a < t:
        k += 1
    return k * b


if __name__ == '__main__':
    print(main(*parse(sys.stdin)))

Failing test case input:
2 -2 6

Expected output:
-6


Actual output:
-4


Fixed submission (verdict: Accepted):

import math
import sys


def parse(file):
    a, b, t = map(int, file.readline().split())
    return a, b, t


def main(a, b, t):
    return math.floor((t + 0.5) / a) * b


if __name__ == '__main__':
    print(main(*parse(sys.stdin)))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C = map(int, input().split())
print(round((C+0.5)/A*B))

Failing test case input:
3 11 -16

Expected output:
-66


Actual output:
-57


Fixed submission (verdict: Accepted):
A,B,C = map(int, input().split())
print(round(C

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = [int(x) for x in input().split()]
sum = b*(t+0.5)
print(sum)

Failing test case input:
17 0 5

Expected output:
0


Actual output:
0.0


Fixed submission (verdict: Accepted):
a, b, t = [int(x) for x in input().split()]
sum = int(b*((t+0.5)
print(sum)

Problem: p03059
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
import math
import sys


def parse(file):
    a, b, t = map(int, file.readline().split())
    return a, b, t


def main(a, b, t):
    k = 0
    while (k + 1) * a < t:
        k += 1
    return k * b


if __name__ == '__main__':
    print(main(*parse(sys.stdin)))

Failing test case input:
2 -7 14

Expected output:
-49


Actual output:
-42


Fixed submission (verdict: Accepted):

import math
import sys


def parse(file):
    a, b, t = map(int, file.readline().split())
    return a, b, t


def main(a, b, t):
    return math.floor((t + 0.5) / a) * b


if __name__ == '__main__':
    print(main(*parse(sys.stdin)))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
hoge = input()
a, b, t = [int(x) for x in hoge.split(' ')]
print(((t+1)%a)*b)

Failing test case input:
2 -8 10

Expected output:
-40


Actual output:
-8


Fixed submission (verdict: Accepted):
hoge = input()

a, b, t = [int(x) for x in hoge.split(' ')]

print(int(((t+0.5)
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t, = map(int, input().split())
ans = 0
t += 0.5

ans += (t / a) * b
print(ans)

Failing test case input:
8 -2 6

Expected output:
0


Actual output:
-1.625


Fixed submission (verdict: Accepted):
a, b, t, = map(int, input().split())
ans = 0
t += 0.5

ans = int((t 
print(ans)

Problem: p03059
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    a, b, k = Input()
    ans = 0
    for i in range(1, k, a):
        ans += b
    print(ans)


main()

Failing test case input:
2 11 -4

Expected output:
-22


Actual output:
0


Fixed submission (verdict: Accepted):
def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


def main():
    a, b, k = Input()
    ans = (k
    print(ans)


main()

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C = map(int, input().split())
print(round(C/A*B))

Failing test case input:
7 22 40

Expected output:
110


Actual output:
126


Fixed submission (verdict: Accepted):
A,B,C = map(int, input().split())
print(round(C

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
print(round((t+0.5)/a)*b)

Failing test case input:
4 13 -2

Expected output:
-13


Actual output:
0


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print(int((t+0.5)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, T= map(int, input().split())

print(round(T/A)*B)

Failing test case input:
12 21 8

Expected output:
0


Actual output:
21


Fixed submission (verdict: Accepted):
A, B, T= map(int, input().split())

print(T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, T = map(int, input().split())
print((T%A)*B)

Failing test case input:
2 43 2

Expected output:
43


Actual output:
0


Fixed submission (verdict: Accepted):
A, B, T = map(int, input().split())
print((T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = map(int, input().split())

print(a + b * t)

Failing test case input:
2 9 12

Expected output:
54


Actual output:
110


Fixed submission (verdict: Accepted):
a, b, t = map(int, input().split())

print(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,c=map(int, input().split())
print(a*(b/c))

Failing test case input:
2 43 4

Expected output:
86


Actual output:
21.5


Fixed submission (verdict: Accepted):
a,b,c=map(int, input().split())
print(b*(c

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math

a, b, t = [int(x) for x in input().split()]
print(math.ceil((t + 0.5) % a) * b)


Failing test case input:
17 23 4

Expected output:
0


Actual output:
115


Fixed submission (verdict: Accepted):
import math

a, b, t = [int(x) for x in input().split()]
print(math.ceil((t + 0.5)
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t=map(int,input().split())
print(t/a*b)

Failing test case input:
2 -8 19

Expected output:
-72


Actual output:
-76.0


Fixed submission (verdict: Accepted):
a,b,t=map(int,input().split())
print(b*(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
n = (t/a)*b
print(int(n))

Failing test case input:
3 5 -2

Expected output:
-5


Actual output:
-3


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
n = (t
print(int(n))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):



A,B,T = map(int,input().split())

C = (T + 1/2)
ans = B*C

print(ans)

Failing test case input:
2 11 -4

Expected output:
-22


Actual output:
-38.5


Fixed submission (verdict: Accepted):



A,B,T = map(int,input().split())

C = int((T + 1/2)
ans = B*C

print(ans)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = map(int, input().split(' '))
(t+0.5)


Failing test case input:
17 -1 8

Expected output:
0


Actual output:

Fixed submission (verdict: Accepted):
a, b, t = map(int, input().split(' '))
print(int((t+0.5)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = map(int, input().split())
print((((t + 0.5) - ((t + 0.5) % a)) / a) * b)

Failing test case input:
2 -5 -1

Expected output:
5


Actual output:
5.0


Fixed submission (verdict: Accepted):
a, b, t = map(int, input().split())
print(int((((t + 0.5) - ((t + 0.5) % a)) / a) * b))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = map(int, input().split())
n = a/t*b


Failing test case input:
2 16 -1

Expected output:
-16


Actual output:

Fixed submission (verdict: Accepted):
a, b, t = map(int, input().split())
t=t+0.5
print(int(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int, input().split())
print(int(t/a * b))

Failing test case input:
10 23 3

Expected output:
0


Actual output:
6


Fixed submission (verdict: Accepted):
a,b,t = map(int, input().split())
print(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int, input().split())
 
print(int((t+0.5)/a*b))

Failing test case input:
1 -8 19

Expected output:
-152


Actual output:
-156


Fixed submission (verdict: Accepted):
a,b,t = map(int, input().split())
 
print((t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,T=map(int,input().split())
print(T/A * B)

Failing test case input:
8 27 -1

Expected output:
-27


Actual output:
-3.375


Fixed submission (verdict: Accepted):
A,B,T=map(int,input().split())
print(T

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import sys
import math

i=list(map(int,input().split()))

a=i[0]
b=i[1]
t=i[2]

ans=t/a*b
print(int(ans))

Failing test case input:
38 1 -1

Expected output:
-1


Actual output:
0


Fixed submission (verdict: Accepted):
import sys
import math

i=list(map(int,input().split()))

a=i[0]
b=i[1]
t=i[2]

ans=math.floor(t/a)*b
print(ans)
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
ans = b*(t+0.5)
print(ans)


Failing test case input:
2 9 12

Expected output:
54


Actual output:
112.5


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print((t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
ans = b * t 
print(ans)

Failing test case input:
2 47 2

Expected output:
47


Actual output:
94


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
ans = b * (t 
print(ans)

Problem: p03059
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,t=I()
time=0
cnt=1
while t+0.5 > time:
    ans +=b
    time+=a*cnt
    cnt+=1

print(ans)


Failing test case input:
10 23 3

Expected output:
0


Actual output:
23


Fixed submission (verdict: Accepted):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

a,b,t=I()


print(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,T = map(int,input().split())
n = T - A
ans  = n*(n+1)*B /2
print(ans)

Failing test case input:
2 9 -4

Expected output:
-18


Actual output:
135.0


Fixed submission (verdict: Accepted):
A,B,T = map(int,input().split())
T += 0.5
ans = int((T

print(ans)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
print(int(t*ｂ/a))

Failing test case input:
10 23 1

Expected output:
0


Actual output:
2


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math

A,B,T = map(int,input().split())

freq = math.floor(((T+0.5)/A))

print(A*freq)

Failing test case input:
1 -7 -1

Expected output:
7


Actual output:
-1


Fixed submission (verdict: Accepted):
import math

A,B,T = map(int,input().split())

freq = math.floor(((T+0.5)/A))
print(B*freq)
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
a,b,t=map(float,input().split())
c = math.floor(t/a)
print(c*b)

Failing test case input:
2 9 12

Expected output:
54


Actual output:
54.0


Fixed submission (verdict: Accepted):
import math
a,b,t=map(float,input().split())
c = round(math.floor(t/a))
print(c*round(b))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
x = (t + 0.5) 
print(x*b)

Failing test case input:
7 6 45

Expected output:
36


Actual output:
273.0


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
x = int((t+0.5) 
print(x*b)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t=map(int,input().split())
print((t/a)*b)


Failing test case input:
4 13 -2

Expected output:
-13


Actual output:
-6.5


Fixed submission (verdict: Accepted):
a,b,c=map(int,input().split())
print(c

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A = list(map(int,input().split()))
print((A[2]-A[2]%A[0])/A[0]*A[1])

Failing test case input:
3 10 11

Expected output:
30


Actual output:
30.0


Fixed submission (verdict: Accepted):
A = list(map(int,input().split()))
print(int((A[2]-A[2]%A[0])/A[0]*A[1]))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = map(int, input().split())

x =(t+0.5)

print(b*x)

Failing test case input:
2 -4 10

Expected output:
-20


Actual output:
-42.0


Fixed submission (verdict: Accepted):
a, b, t = map(int, input().split())

x =int((t+0.5)

print(x)

Problem: p03059
Buggy submission (PyPy3 (2.4.0), verdict: Wrong Answer):
A,B,T=map(int,input().split());print(T/A*B)

Failing test case input:
2 43 2

Expected output:
43


Actual output:
43.0


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print((t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t = map(int,input().split())
print((t%a) * b)

Failing test case input:
2 -3 10

Expected output:
-15


Actual output:
0


Fixed submission (verdict: Accepted):
a,b,t = map(int,input().split())
print((t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t=list(map(int,input().split()))
print(t*(b/a))


Failing test case input:
5 38 11

Expected output:
76


Actual output:
83.6


Fixed submission (verdict: Accepted):
a,b,t=list(map(int,input().split()))
print((t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a, b, t = map(int, input().split())

x = round((t+0.5)/a)
print(b*x)


Failing test case input:
1 -7 -1

Expected output:
7


Actual output:
0


Fixed submission (verdict: Accepted):
from math import floor
a, b, t = map(int, input().split())

x = floor((t+0.5)/a)
print(b*x)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,C=map(int,input().split())
print(int((A%(C+0.5))*B))


Failing test case input:
2 11 -4

Expected output:
-22


Actual output:
-16


Fixed submission (verdict: Accepted):
A,B,C=map(int,input().split())
print(int(((C+0.5)
Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
a,b,t=map(int,input().split())
n=t
print(b*n*(n+1)/2)

Failing test case input:
6 -3 10

Expected output:
-3


Actual output:
-165.0


Fixed submission (verdict: Accepted):
a,b,t=map(int,input().split())
print(b*(t

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A,B,T = map(int,input().split())
n = T - A
ans  = n*(n+1)/2
print(ans)

Failing test case input:
17 -1 8

Expected output:
0


Actual output:
36.0


Fixed submission (verdict: Accepted):
A,B,T = map(int,input().split())
T += 0.5
ans = int((T

print(ans)

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
import math
l = list(map(int, input().split()))
print(l[1]*(l[2]-(l[2]%l[0]))/l[0])

Failing test case input:
5 38 11

Expected output:
76


Actual output:
76.0


Fixed submission (verdict: Accepted):
import math
l = list(map(int, input().split()))
print(int(l[1]*(l[2]-(l[2]%l[0]))/l[0]))

Problem: p03059
Buggy submission (Python (3.4.3), verdict: Wrong Answer):
A, B, T = map(int, input().split())

if T <= A:
  print(0)
else:
  print(B*int(T/A))


Failing test case input:
2 16 -1

Expected output:
-16


Actual output:
0


Fixed submission (verdict: Accepted):
A, B, T = map(int, input().split())

if T < A:
  print(0)
else:
  print(B*(T
Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K=int(input())
ans = False
M,N = map(int,input().rstrip().split(" ")) 

for number in range(M,N+1):
    if number%K==0:
        ans = True
if ans:
    print("YES")
else:
    print("NG")

Failing test case input:
4
2 20

Expected output:
OK


Actual output:
YES


Fixed submission (verdict: Accepted):
K=int(input())
ans = False
M,N = map(int,input().rstrip().split(" ")) 

for number in range(M,N+1):
    if number%K==0:
        ans = True
if ans:
    print("OK")
else:
    print("NG")

Problem: p02693
Buggy submission (PyPy3 (7.3.0), verdict: Wrong Answer):
K = int(input())

A, B = map(int, input().split())

for x in range(A, B+1):
  if x % 7 == 0:
    print("OK")
  else: 
    print("NG")



Failing test case input:
4
-2 6

Expected output:
OK


Actual output:
NG
NG
OK
NG
NG
NG
NG
NG
NG


Fixed submission (verdict: Accepted):
K = int(input())

A, B = map(int, input().split())

flag = False
for x in range(A, B+1):
  if x % K == 0:
    flag = True


if flag:
  print("OK")
else: 
  print("NG")

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K=int(input())
A,B=list(map(int,input().split()))
a=A/K
b=B/K

if A%K==0 or B%K==0 or (a-b)<=-1 or 1<=(a-b):
    print('OK')
else:
    print('NG')

Failing test case input:
4
2 5

Expected output:
OK


Actual output:
NG


Fixed submission (verdict: Accepted):
K=int(input())
A,B=list(map(int,input().split()))
a=int(A/K)
b=B/K

if A%K==0 or B%K==0 or (a+1)*K<=B:
    print('OK')
else:
    print('NG')

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
n = int(input())
A, B = map(int, input().split())

n_1 = int(A / n)
n_2 = int(B / n)
nn_1 = A%n
nn_2 = B%n

print(n_1,n_2)
if n == 1: print('OK')
else:
    if nn_1 ==0 or nn_2 == 0:print('OK')
    elif n_2 != n_1: print('OK')
    else: print('NG')


Failing test case input:
4
6 8

Expected output:
OK


Actual output:
1 2
OK


Fixed submission (verdict: Accepted):
n = int(input())
A, B = map(int, input().split())

n_1 = int(A / n)
n_2 = int(B / n)
nn_1 = A%n
nn_2 = B%n
if n == 1: print('OK')
else:
    if nn_1 ==0 or nn_2 == 0:print('OK')
    elif n_2 != n_1: print('OK')
    else: print('NG')

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k = int(input())
a, b = map(int, input().split())

if a <= (b / k) * k: print('OK')

print('NG') 

Failing test case input:
4
0 46

Expected output:
OK


Actual output:
OK
NG


Fixed submission (verdict: Accepted):
k = int(input())
a, b = map(int, input().split())

if a <= int(b / k) * k: print('OK')
else: print('NG')

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K=int(input())
A,B=list(map(int,input().split()))
n=int(A/K)
m=int(B/K)
if K==1:
  print("OK")
elif n-m>=1:
  print("OK")
else:
  print("NG")

Failing test case input:
4
-1 95

Expected output:
OK


Actual output:
NG


Fixed submission (verdict: Accepted):
K=int(input())
A,B=list(map(int,input().split()))
n=int(A/K)
m=int(B/K)
if K==1:
  print("OK")
elif A/K-n==0.0 or B/K-m==0.0:
  print("OK")
elif m-n>=1:
  print("OK")
else:
  print("NG")
Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k = int(input())

a, b = map(int, input().split())

c = b - a

if c >= k or a % k == 0 or b % k == 0:
    print('OK')
else:
    print('NG')


Failing test case input:
4
6 9

Expected output:
OK


Actual output:
NG


Fixed submission (verdict: Accepted):
k = int(input())

a, b = map(int, input().split())

c = b - a

d = b % k

if c >= d:
    print('OK')
else:
    print('NG')

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K = int(input())
S, W = map(int, input().split())

for i in range(S, W+1):
    if i%K==0:
        print("OK")
        exit()
else:print("NO")

Failing test case input:
4
2 2

Expected output:
NG


Actual output:
NO


Fixed submission (verdict: Accepted):
K = int(input())
S, W = map(int, input().split())

for i in range(S, W+1):
    if i%K==0:
        print("OK")
        exit()
else:print("NG")

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k=int(input())
a,b=map(int,input().split())
for i in range(a,b+1):
    if i%k==0:
        print("OK")
        break
else:
    print("NO")

Failing test case input:
4
1 1

Expected output:
NG


Actual output:
NO


Fixed submission (verdict: Accepted):
k=int(input())
a,b=map(int,input().split())
for i in range(a,b+1):
    if i%k==0:
        print("OK")
        break
else:
    print("NG")

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K = list(map(int,input().split()))[0]
A,B = list(map(int,input().split()))


def is_ok(k, a, b):
  for i in range(a, b+1):
    if i % k == 0:
      return True
  return False


print(is_ok(K, A, B))

Failing test case input:
4
-2 18

Expected output:
OK


Actual output:
True


Fixed submission (verdict: Accepted):
K = list(map(int,input().split()))[0]
A,B = list(map(int,input().split()))

def is_ok(k, a, b):
  for i in range(a, b+1):
    if i % k == 0:
      return True
  return False

print('OK' if is_ok(K, A, B) else 'NG')

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
k = int(input())
a, b = map(int, input().split())
judge = 0
for i in range(b-a):
    if a+i % k == 0:
        judge = 1
if judge == 1:
    print("OK")
else:
    print("NG") 

Failing test case input:
4
8 18

Expected output:
OK


Actual output:
NG


Fixed submission (verdict: Accepted):
k = int(input())
a, b = map(int, input().split())
judge = 0
for i in range(b-a+1):
    if (a+i) % k == 0:
        judge = 1
if judge == 1:
    print("OK")
else:
    print("NG")

Problem: p02693
Buggy submission (Python (3.8.2), verdict: Wrong Answer):
K=int(input())
A,B=map(int,input().split())
print("OK" if B-A>=K-1 else "NG")

Failing test case input:
4
2 4

Expected output:
OK


Actual output:
NG


Fixed submission (verdict: Accepted):
K=int(input())
A,B=map(int,input().split())
print("OK" if B