Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
import math
D, G = map(int, input().split())
P = []
C = []
for i in range(D):
    p, c = map(int, input().split())
    P.append(p)
    C.append(c)

used = [False for i in range(D)]


def check_goal(P, C, rest):
    result = []
    for i in range(len(P)):
        if used:
            continue
        if rest < 100 * (i + 1) * P[i]:
            result.append(math.ceil(rest // 100 * (i + 1)))
        elif rest <= 100 * (i + 1) * P[i] + C[i]:
            result.append(P[i])
        else:
            result.append(float("inf"))
    return result


def get_scores_best(P, C, rest):
    scores = [(100 * (i + 1), i) if 100 * (i + 1) * P[i] > rest else (100 *
                                                                      (i + 1) + C[i] / P[i], i) for i in range(len(P))]
    scores.sort(key=lambda x: x[0])
    scores.reverse()
    while True:
        j = 0
        if used[scores[j][1]]:
            j += 1
            continue
        else:
            return scores[j]


def judge(P, C, G):
    rest = G
    count = 0
    while True:
        count_list = check_goal(P, C, rest)
        if min(count_list) != float("inf"):
            count += min(count_list)
            return count
        else:
            score, i = get_scores_best(P, C, rest)
            count += P[i]
            rest -= 100 * (i + 1) * P[i] + C[i]
            print(rest)
            used[i] = True


print(judge(P, C, G))


Fixed submission:
D, G = map(int, input().split())
P = []
C = []
for i in range(D):
    p, c = map(int, input().split())
    P.append(p)
    C.append(c)


def bit_search(A):
    result = []
    for i in range(1 << len(A)):
        output = []
        for j in range(len(A)):
            if ((i >> j) & 1) == 1:
                output.append(A[j])
        result.append(output)

    return result


search_list = bit_search(list(range(D)))
ans = 10 ** 9
for complete_list in search_list:
    score = sum([100 * (i + 1) * P[i] + C[i] for i in complete_list])
    count = sum([P[i] for i in complete_list])
    if score >= G:
        ans = min(ans, count)
    else:
        j_max = max([i for i in range(D) if i not in complete_list])
        required = -(-(G - score) // (100 * (j_max + 1)))
        if required < P[j_max]:
            count += required
            ans = min(ans, count)
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
import itertools


def get_discomfort(group, color, D):
    s = 0
    for c in group:
        s += D[c - 1][color - 1]
    return s


N, C = map(int, input().split())
D = [list(map(int, input().split())) for _ in range(C)]


grids = [[], [], []]
for i in range(N):
    c = list(map(int, input().split()))
    for j in range(N):
        grids[(i + j) % 3].append(c[j])

ans = float("inf")
for colors in itertools.permutations(list(range(C)), 3):
    colors = list(colors)
    s = 0
    for i, c in enumerate(colors):
        s += get_discomfort(grids[i], c, D)
    ans = min(ans, s)

print(ans)


Fixed submission:
import itertools


def get_discomfort(group_dic, color, D):
    s = 0
    for c, num in group_dic.items():
        s += D[c - 1][color - 1] * num
    return s


N, C = map(int, input().split())
D = [list(map(int, input().split())) for _ in range(C)]


from collections import Counter


grids = [Counter() for _ in range(3)]

for i in range(N):
    c = list(map(int, input().split()))
    for j in range(N):
        grids[(i + j) % 3][c[j]] += 1


ans = float("inf")
for colors in itertools.permutations(list(range(C)), 3):
    colors = list(colors)
    s = 0
    for i, c in enumerate(colors):
        s += get_discomfort(grids[i], c, D)
    ans = min(ans, s)

print(ans)
Buggy python submission (verdict: Runtime Error):
A, B = map(int, input().split())
if A + B < C:
    print("No")
else:
    print("Yes")


Fixed submission:
A, B, C = map(int, input().split())
if A + B < C:
    print("No")
else:
    print("Yes")
Buggy python submission (verdict: Runtime Error):
from functools import reduce
from itertools import combinations
N = int(input())
S = {"M": [], "A": [], "R": [], "C": [], "H": []}
for _ in range(N):
    i = input()
    head = i[0]
    if head == "M":
        S["M"].append(i)
    elif head == "A":
        S["A"].append(i)
    elif head == "R":
        S["R"].append(i)
    elif head == "C":
        S["C"].append(i)
    elif head == "H":
        S["H"].append(i)
result = [len(S[head]) for head in list("MARCH") if len(S[head]) != 0]

ans = sum([reduce(lambda x, y: x * y, list(combinations(result, 3))[i])
           for i in range(len(result))])
print(ans)


Fixed submission:
from functools import reduce
from itertools import combinations
N = int(input())
S = {"M": [], "A": [], "R": [], "C": [], "H": []}
for _ in range(N):
    i = input()
    head = i[0]
    if head == "M":
        S["M"].append(i)
    elif head == "A":
        S["A"].append(i)
    elif head == "R":
        S["R"].append(i)
    elif head == "C":
        S["C"].append(i)
    elif head == "H":
        S["H"].append(i)
counter = [len(S[head]) for head in list("MARCH") if len(S[head]) != 0]
combs = list(combinations(counter, 3))
ans = sum([reduce(lambda x, y: x * y, e) for e in combs])
print(ans)

Buggy python submission (verdict: Runtime Error):
from functools import reduce
from itertools import combinations
N = int(input())
S = {"M": set([]), "A": set([]), "R": set([]), "C": set([]), "H": set([])}
for _ in range(N):
    i = input()
    head = i[0]
    if head == "M":
        S["M"].add(i)
    elif head == "A":
        S["A"].add(i)
    elif head == "R":
        S["R"].add(i)
    elif head == "C":
        S["C"].add(i)
    elif head == "H":
        S["H"].add(i)
result = [len(S[head]) for head in list("MARCH") if len(S[head]) != 0]

ans = sum([reduce(lambda x, y: x * y, list(combinations(result, 3))[i])
           for i in range(len(result))])
print(ans)


Fixed submission:
from functools import reduce
from itertools import combinations
N = int(input())
S = {"M": [], "A": [], "R": [], "C": [], "H": []}
for _ in range(N):
    i = input()
    head = i[0]
    if head == "M":
        S["M"].append(i)
    elif head == "A":
        S["A"].append(i)
    elif head == "R":
        S["R"].append(i)
    elif head == "C":
        S["C"].append(i)
    elif head == "H":
        S["H"].append(i)
counter = [len(S[head]) for head in list("MARCH") if len(S[head]) != 0]
combs = list(combinations(counter, 3))
ans = sum([reduce(lambda x, y: x * y, e) for e in combs])
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
N, H = map(int, input().split())
A = []
B = []
for i in range(N):
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)

max_a = max(A)
filtered = [b_i for b_i in B if b_i > max_a]
sum_b = sum(filtered)
if sum_b <= H:
    print(-(-(H - sum_b) // max_a) + len(filtered))
else:
    filtered.sort()
    filtered.reverse()
    print(len([x for x in [sum(filtered[:i + 1])
                           for i in range(N)] if x < H]) + 1)


Fixed submission:
N, H = map(int, input().split())
A = []
B = []
for i in range(N):
    a, b = map(int, input().split())
    A.append(a)
    B.append(b)

max_a = max(A)
filtered = [b_i for b_i in B if b_i > max_a]
sum_b = sum(filtered)
if sum_b <= H:
    print(-(-(H - sum_b) // max_a) + len(filtered))
else:
    filtered.sort()
    filtered.reverse()
    s = 0
    for i in range(len(filtered)):
        s += filtered[i]
        if s >= H:
            print(i + 1)
            break
Buggy python submission (verdict: Runtime Error):
from functools import reduce
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if b > a:
        b, a = a, b
    return int(a * b / gcd(a, b))


x = reduce(lcm, T)
print(x)


Fixed submission:
from functools import reduce
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if b > a:
        b, a = a, b
    return a * b // gcd(a, b)


x = reduce(lcm, T)
print(x)

Buggy python submission (verdict: Runtime Error):
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if a > b:
        g = gcd(a, b)
        return int(a / g * b)
    else:
        g = gcd(b, a)
        return int(b / g * a)


x = T[0]
for i in range(1, N):
    x = lcm(x, T[i])

print(x)


Fixed submission:
from functools import reduce
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if b > a:
        b, a = a, b
    return a * b // gcd(a, b)


x = reduce(lcm, T)
print(x)

Buggy python submission (verdict: Runtime Error):
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if a > b:
        g = gcd(a, b)
    else:
        g = gcd(b, a)
    return int(a / g * b)


x = T[0]
for i in range(1, N):
    x = lcm(x, T[i])

print(x)


Fixed submission:
from functools import reduce
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if b > a:
        b, a = a, b
    return a * b // gcd(a, b)


x = reduce(lcm, T)
print(x)

Buggy python submission (verdict: Runtime Error):
import math
from functools import reduce
T = []
N = int(input())
for i in range(N):
    T.append(int(input()))


def lcm(a, b):
    g = math.gcd(a, b)
    return int(a / g * b)


x = T[0]
for i in range(1, N):
    x = lcm(x, T[i])

print(int(x))


Fixed submission:
from functools import reduce
N = int(input())
T = []
for _ in range(N):
    T.append(int(input()))


def gcd(a, b):
    if b == 0:
        return a
    else:
        return gcd(b, a % b)


def lcm(a, b):
    if b > a:
        b, a = a, b
    return a * b // gcd(a, b)


x = reduce(lcm, T)
print(x)
Buggy python submission (verdict: Runtime Error):
n.m = map(int, input().split())
print((n - 1) * (m - 1))


Fixed submission:
n, m = map(int, input().split())
print((n - 1) * (m - 1))
Buggy python submission (verdict: Runtime Error):
c = list()
for i in range(6):
  c.append(int(input()))
if coo[4] - coo[0] > coo[5]:
  print(":(")
else:
  print("Yay!")

Fixed submission:
c = list()
for i in range(6):
  c.append(int(input()))
if c[4] - c[0] > c[5]:
  print(":(")
else:
  print("Yay!")

Buggy python submission (verdict: Runtime Error):
C = list()
for i in range(6):
    coo.append(int(input()))
  if coo[4] - coo[0] > coo[5]:
    print(":(")
  else:
    print("Yay!")

Fixed submission:
c = list()
for i in range(6):
  c.append(int(input()))
if c[4] - c[0] > c[5]:
  print(":(")
else:
  print("Yay!")
Buggy python submission (verdict: Runtime Error):
[A,B,C]=list(map(int,input().sprit))

print(min(C,B//A))

Fixed submission:
[A,B,C] = list(map(int,input().split()))
print(min(C,B//A))
Buggy python submission (verdict: Runtime Error):
a,b,c=map(str,input().split())

print('A'b[0]'C')

Fixed submission:
a,b,c=map(str,input().split())
print('A'+b[0]+'C')
Buggy python submission (verdict: Runtime Error):
a, b = map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
        
elif a > 0:
     ans='Positive'
else
     ans='Zero'
  
print(ans)

Fixed submission:
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else:
 ans='Zero'
  
print(ans)

Buggy python submission (verdict: Runtime Error):
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else
 ans='Zero'
  
print(ans)

Fixed submission:
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else:
 ans='Zero'
  
print(ans)

Buggy python submission (verdict: Runtime Error):
a,b=map(int, input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else
 ans='Zeros'
  
print(ans)

Fixed submission:
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else:
 ans='Zero'
  
print(ans)

Buggy python submission (verdict: Runtime Error):
a,b=int(input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else
 ans='Zeros'
  
print(ans)

Fixed submission:
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else:
 ans='Zero'
  
print(ans)

Buggy python submission (verdict: Runtime Error):
a,b=int(input().split())
if a*(a+1)*b==0:
  print('Zero')
if a*(a+1)*b<0:
  print('Negative')
if a*(a+1)*b>0:
  print('Positive')

Fixed submission:
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else:
 ans='Zero'
  
print(ans)

Buggy python submission (verdict: Runtime Error):
a,b=int(input().split())
if a*b==0:
  print('Zero')
if a*b<0:
  print('Negative')
if a*b>0:
  print('Positive')

Fixed submission:
a,b=map(int,input().split())
if b < 0:
    if (b-a+1) % 2 == 0:
        ans = 'Positive'
    elif (b-a+1) % 2 == 1:
        ans = 'Negative'
elif a > 0:
 ans='Positive'
else:
 ans='Zero'
  
print(ans)
Buggy python submission (verdict: Runtime Error):
N, K = map(int, input().split())
input = list(map(int, input().split()))

count, sum, start = 0, 0, 0
substring = []
while (True):
    sum += input[count]
    substring.append(sum)
    if start == len(input) - 1:
        break
    if count == len(input) - 1:
        start += 1
        count = start
        sum = 0
        continue

    count += 1
substring.sort(reverse=True)

result = substring[0]
for i in range(1, K):
    result = result & substring[i]

print(result)


Fixed submission:
from statistics import mean

frame_num = int(input())
frame_value = list(map(int, input().split()))
avg = mean(frame_value)
min_frame = max(frame_value)
thumbanil = 0
for frame, value in enumerate(frame_value):
    diff = abs(avg - value)
    # print(diff, value, frame)
    if diff < min_frame:
        min_frame = diff
        thumbanil = frame

print(thumbanil)
Buggy python submission (verdict: Runtime Error):
nums = []

for i in range(5):
  nums.append(input())

k = input()

for i in range(5):
  for j in range(5-i)[1:]:
    if nums[j] - nums[i] > k:
      print ":("
      return

print "Yay!"
return
      

Fixed submission:
import sys

nums = []

for i in range(5):
  nums.append(int(input()))

k = int(input())

for i in range(5):
  for j in range(5-i)[1:]:
    if nums[j] - nums[i] > k:
      print(":(")
      sys.exit()

print("Yay!")
Buggy python submission (verdict: Time Limit Exceeded):
numberOfToorists = int(input())

residents = [0,0,0,0,0,0]

transportCapacity = [0,0,0,0,0]
migrants = [0,0,0,0,0]

elapsedTime = 0

for i in range(5):
	transportCapacity[i] = int(input())

residents[0] = numberOfToorists

while residents[5] < numberOfToorists:
	for i in range(5):
		if residents[i] >= transportCapacity[i]:
			migrants[i] = transportCapacity[i]
		else:
			migrants[i] = residents[i]

	for i in range(5):
		residents[i] -= migrants[i]
		residents[i+1] += migrants[i]

	elapsedTime += 1

print(elapsedTime)

Fixed submission:
numberOfToorists = int(input())

minimumCapacity = 10.0**16

for i in range(5):
	vehicleCapacity = int(input())
	minimumCapacity = min(minimumCapacity, vehicleCapacity)

bottleNeckTime = int(numberOfToorists / minimumCapacity)

if numberOfToorists % minimumCapacity > 0:
	bottleNeckTime += 1

requiredTime = bottleNeckTime + 4

print(requiredTime)
Buggy python submission (verdict: Runtime Error):
a,b,c,d,e,k = map(int, input().split())
if e-a<=k and e-b<=k and e-c<=k and e-d<=k:
 print(':(')
else:
 print('Yay!')

Fixed submission:
a=int(input())
b=int(input())
c=int(input())
d=int(input())
e=int(input())
k=int(input())
if e-a<=k and e-b<=k and e-c<=k and e-d<=k:
 print('Yay!')
else:
 print(':(')
Buggy python submission (verdict: Runtime Error):
N=int(input())
i=int(input())
print(N-i+1)


Fixed submission:
N,i=map(int, input().split())
print(N-i+1)

Buggy python submission (verdict: Runtime Error):
N=int(input())
i=int(input())
print(N-i+1)

Fixed submission:
N,i=map(int, input().split())
print(N-i+1)
Buggy python submission (verdict: Runtime Error):
a,b = map(int, input().split())
a == 1
b == 1
for i in range(100):
	a = a + i
    for j in range(100):
		b = b + j
		c = (a-1) * (b-1)

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

Buggy python submission (verdict: Runtime Error):
a,b = map(int, input().split())
for 2 in range(100):
	c = (a-1) * (b-1)

Fixed submission:
a,b = map(int, input().split())
c = (a-1) * (b-1)
print(c)
Buggy python submission (verdict: Runtime Error):
N,K=map(int, input().split())
if N % K = 0:
 print(0)
else:
 print(1)

Fixed submission:
N,K=map(int, input().split())
if N % K == 0:
 print(0)
else:
 print(1)

Buggy python submission (verdict: Runtime Error):
N,K=map(int, inpu().split())
if N % K = 0:
 print(0)
else:
 print(1)

Fixed submission:
N,K=map(int, input().split())
if N % K == 0:
 print(0)
else:
 print(1)
Buggy python submission (verdict: Runtime Error):
N = int(input())

if N % 2 = 0:
 print(N)
else:
 print(N*2)

Fixed submission:
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(N * 2)
Buggy python submission (verdict: Runtime Error):
H = list(map(int, input().split())
print(max(H)-min(H))

Fixed submission:
N = int(input())
A = list(map(int, input().split()))
print(max(A)-min(A))
Buggy python submission (verdict: Runtime Error):
S=input()
if S.count('+') = 0:
 print(-4)
elif S.count('+') = 1:
 print(-2)
elif S.count('+') = 2:
 print(0)
elif S.count('+') = 3:
 print(2)
else:
 print(4)

Fixed submission:
S=input()
if S.count('+') == 0:
 print(-4)
elif S.count('+') == 1:
 print(-2)
elif S.count('+') == 2:
 print(0)
elif S.count('+') == 3:
 print(2)
else:
 print(4)
Buggy python submission (verdict: Runtime Error):
b=input()

if b='A':
  print('T')
elif b='T':
  print('A')
elif b='G':
  print('C')
else:
  print('G')

Fixed submission:
b=input()
 
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='G':
    print('C')
else:
    print('G')

Buggy python submission (verdict: Runtime Error):
b=input()
if b=A:
  print("T")
if b=T:
  print("A")
if b=C: 
  print("G")
if b=G: 
  print("C")

Fixed submission:
b=input()
 
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='G':
    print('C')
else:
    print('G')

Buggy python submission (verdict: Runtime Error):
b=input()
if b=A:
  print("T")
if b=T:
  print("A")
if b=C: 
  print("G")
if b=G  
  print("C")

Fixed submission:
b=input()
 
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='G':
    print('C')
else:
    print('G')

Buggy python submission (verdict: Runtime Error):
b=int(input())
if b=A:
  print(T)
if b=T:
  print(A)
if b=C: 
  print(G)
if b=G  
  print(C)

Fixed submission:
b=input()
 
if b=='A':
    print('T')
elif b=='T':
    print('A')
elif b=='G':
    print('C')
else:
    print('G')
Buggy python submission (verdict: Runtime Error):
a=list(map(int,input().split()))
b=list(map(int,input().split()))
print(a[0]-b[0])*(a[1]-b[1])

Fixed submission:
a=list(map(int,input().split()))
b=list(map(int,input().split()))
print((a[0]-b[0])*(a[1]-b[1]))

Buggy python submission (verdict: Runtime Error):
a=list(int(input().split()))
b=list(int(input().split()))
print(a[0]-b[0])*(a[1]-b[1])

Fixed submission:
a=list(map(int,input().split()))
b=list(map(int,input().split()))
print((a[0]-b[0])*(a[1]-b[1]))

Buggy python submission (verdict: Runtime Error):
a=list(int(input().split()))
b=list(int(input().split()))

s=(a[0]-b[0])*(a[0]-b[0])
print(s)

Fixed submission:
a=list(map(int,input().split()))
b=list(map(int,input().split()))
print((a[0]-b[0])*(a[1]-b[1]))

Buggy python submission (verdict: Runtime Error):
a=list(int(input(),split()))
b=list(int(input(),split()))

s=(a[0]-b[0])*(a[1]-b[1])
print(s)

Fixed submission:
a=list(map(int,input().split()))
b=list(map(int,input().split()))
print((a[0]-b[0])*(a[1]-b[1]))
Buggy python submission (verdict: Runtime Error):
a=list(map(int, input().split().split()))

if a[1]//a[0]>=a[2]:
    print(a[2])
else:
    print(a[1]//a[0])


Fixed submission:
a=list(map(int, input().split()))
 
if a[1]/a[0]>=a[2]:
    print(a[2])
else:
    print(a[1]//a[0])
Buggy python submission (verdict: Runtime Error):
a,b,c,d,e,k = int(input()) for i in range(6)
print("Yay!" if (e - a <= k) else ":(")

Fixed submission:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
k = int(input())
if( e - a > k):
	print(":(")
else:
	print("Yay!")

Buggy python submission (verdict: Runtime Error):
# -*- coding: utf-8 -*-
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
k = int(input())
if( e - a > k):
	print(':)')
else:
	print('Yay'")

Fixed submission:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
e = int(input())
k = int(input())
if( e - a > k):
	print(":(")
else:
	print("Yay!")
Buggy python submission (verdict: Runtime Error):
A = int(input())
B = int(input())
C = int(input())
D = int(input())
E = int(input())

sample_list = []
sample_list.append(a)
sample_list.append(b)
sample_list.append(c)
sample_list.append(d)
sample_list.append(e)

x = []
for i in sample_list:
  if i%10 == 0:
    x.append(0)
  else:
    x.append(10-(i%10))

print(sum(sample_list)+sum(x)-max(x))
              

Fixed submission:
a =int(input())
b =int(input())
c =int(input())
d =int(input())
e =int(input())
sample_list = []
sample_list.append(a)
sample_list.append(b)
sample_list.append(c)
sample_list.append(d)
sample_list.append(e)
x = []
for i in sample_list:
  if i%10 == 0:
    x.append(0)
  else:
    x.append(10-(i%10))
print(sum(sample_list)+sum(x)-max(x))

Buggy python submission (verdict: Runtime Error):
a =int(input())
b =int(input())
c =int(input())
d =int(input())
e =int(input())
sample_list = []
sample_list.append(a)
sample_list.append(b)
sample_list.append(c)
sample_list.append(d)
sample_list.append(e)
x = []
for i in sample_list:
  if i%10 == 0:
    x.append(0)
  else:
    x.append(10-(i%10))
print(sam(sample_list)+sam(x)-max(x))

Fixed submission:
a =int(input())
b =int(input())
c =int(input())
d =int(input())
e =int(input())
sample_list = []
sample_list.append(a)
sample_list.append(b)
sample_list.append(c)
sample_list.append(d)
sample_list.append(e)
x = []
for i in sample_list:
  if i%10 == 0:
    x.append(0)
  else:
    x.append(10-(i%10))
print(sum(sample_list)+sum(x)-max(x))

Buggy python submission (verdict: Runtime Error):
a =int(input())
b =int(input())
c =int(input())
d =int(input())
e =int(input())
sample_list = []
sample_list.append(a)
sample_list.append(b)
sample_list.append(c)
sample_list.append(d)
sample_list.append(e)
x = []
for i in sample_list:
  if i%10 = 0:
    x.append(0)
  else:
    x.append(10-(i%10))
print(sam(sample_list)+sam(x)-max(x))

Fixed submission:
a =int(input())
b =int(input())
c =int(input())
d =int(input())
e =int(input())
sample_list = []
sample_list.append(a)
sample_list.append(b)
sample_list.append(c)
sample_list.append(d)
sample_list.append(e)
x = []
for i in sample_list:
  if i%10 == 0:
    x.append(0)
  else:
    x.append(10-(i%10))
print(sum(sample_list)+sum(x)-max(x))
Buggy python submission (verdict: Runtime Error):
b = input()
if(b == "A"):
  print("T")
elif(b == "T"):
  print("A")
elif(b == "C"):
  print("G"):
else:
  print("C")

Fixed submission:
b = input()
if(b == "A"):
  print("T")
elif(b == "T"):
  print("A")
elif(b == "C"):
  print("G")
else:
  print("C")