Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
h = list(map(int, input().split()))
c = 0
for i in range(n-1):
    if c >= n - i:
        break
    tmp = 0
    for j in range(i, n-1):
        if h[j] >= h[j+1]:
            tmp += 1
        else:
            break
    c = max(tmp, c)
print(c)


Fixed submission:
n = int(input())
h = list(map(int, input().split()))
dp = [0] * n
for i in range(1, n):
    if h[i-1] >= h[i]:
        dp[i] = dp[i-1] + 1
print(max(dp))

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
h = list(map(int, input().split()))
c = 0
for i in range(n-1):
    tmp = 0
    for j in range(i, n-1):
        if h[j] >= h[j+1]:
            tmp += 1
        else:
            break
    c = max(tmp, c)
print(c)


Fixed submission:
n = int(input())
h = list(map(int, input().split()))
dp = [0] * n
for i in range(1, n):
    if h[i-1] >= h[i]:
        dp[i] = dp[i-1] + 1
print(max(dp))
Buggy python submission (verdict: Runtime Error):
import sys
from collections import defaultdict, deque
from functools import reduce
import math

input = sys.stdin.readline

def chmax(a, b):
    if a > b:
        return a
    else:
        return b

def lcm_base(x, y):
    return (x * y) // math.gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

def main():
    N = int(input())
    T = [int(input()) for _ in range(N)]
    print(lcm(*T))


if __name__ == '__main__':
    main()


Fixed submission:
import sys
from collections import defaultdict, deque
from functools import reduce
import math

input = sys.stdin.readline

def chmax(a, b):
    if a > b:
        return a
    else:
        return b
    
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm_base(x, y):
    return (x * y) // gcd(x, y)

def lcm(*numbers):
    return reduce(lcm_base, numbers, 1)

def lcm_list(numbers):
    return reduce(lcm_base, numbers, 1)

def main():
    N = int(input())
    T = [int(input()) for _ in range(N)]
    print(lcm(*T))


if __name__ == '__main__':
    main()
Buggy python submission (verdict: Time Limit Exceeded):
import math
A, B, N  = map(int, input().split())

max_v = 0
for x in range(min(B+1, N+1)):
    v = math.floor(A*x/B) - A*math.floor(x/B)
    if max_v < v:
        max_v = v
print(max_v)

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

max_v = 0
for x in range(-1, min(B, N+1), min(B, N+1)):
    if x <= 0:
        continue
    v = math.floor(A*x/B) - A*math.floor(x/B)
    if max_v < v:
        max_v = v
print(max_v)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
p = list(map(int , input().split()))

ret = 1
for i in range(1, len(p)):
    if min(p[:i]) > p[i]:
        ret +=1
print(ret) 

Fixed submission:
N = int(input())
p = list(map(int , input().split()))

ret = 0
c_min = 2e5

for i in p:
    if c_min >= i:
        c_min = i
        ret+=1
print(ret)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np

N = int(input())
p = list(map(int , input().split()))

ret = 0
p = np.array(p)
for i in range(len(p)):
    if (p[:i] > p[i]).all():
        ret +=1
print(ret)      

Fixed submission:
N = int(input())
p = list(map(int , input().split()))

ret = 0
c_min = 2e5

for i in p:
    if c_min >= i:
        c_min = i
        ret+=1
print(ret)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np

N = int(input())
p = list(map(int , input().split()))

ret = 0
for i in range(len(p)):
    if (np.array(p[:i]) > p[i]).all():
        ret +=1
print(ret)        

Fixed submission:
N = int(input())
p = list(map(int , input().split()))

ret = 0
c_min = 2e5

for i in p:
    if c_min >= i:
        c_min = i
        ret+=1
print(ret)
Buggy python submission (verdict: Runtime Error):
import math

a = list(map(int , input().split()))
A = a[0]
B = a[1]

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

print(lcm(A, B))

Fixed submission:
import fractions

a = list(map(int , input().split()))
A = a[0]
B = a[1]

def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)

print(int(lcm(A, B)))
Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
N= int(input())
a = list(map(int, input().split(' ')))
#N = 5
#a = [3, 2, 2, 4, 1]


a = np.array(a, dtype=int)
for i in range(N):
    ind = np.ones(N, dtype=bool)
    ind[i] = False
    tmp = a[ind]
    print(int(np.median(tmp)))

Fixed submission:
import numpy as np
N= int(input())
a = list(map(int, input().split(' ')))
sort_a = sorted(a)
small = sort_a[N//2-1]
big = sort_a[N//2]
for aa in a:
    if aa < big:
        print(big)
    else:
        print(small)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
N= int(input())
a = list(map(int, input().split(' ')))
a = np.array(a)
ret = []
for i in range(N):
    ind = np.ones(N, dtype=bool)
    ind[i] = False
    tmp = a[ind]
    print(int(np.median(tmp)))

Fixed submission:
import numpy as np
N= int(input())
a = list(map(int, input().split(' ')))
sort_a = sorted(a)
small = sort_a[N//2-1]
big = sort_a[N//2]
for aa in a:
    if aa < big:
        print(big)
    else:
        print(small)

Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
N= int(input())
a = list(map(int, input().split(' ')))
a = np.array(a)
ret = []
for i in range(N):
    ind = np.ones(N, dtype=bool)
    ind[i] = False
    tmp = a[ind]
    ret.append(np.median(tmp))
for rett in ret:
  print(int(rett))

Fixed submission:
import numpy as np
N= int(input())
a = list(map(int, input().split(' ')))
sort_a = sorted(a)
small = sort_a[N//2-1]
big = sort_a[N//2]
for aa in a:
    if aa < big:
        print(big)
    else:
        print(small)
Buggy python submission (verdict: Runtime Error):
result = 0
for b in range(K + 1, N + 1):
    result += (N // b) * (b - K) + max(N - (N // b) * b - max(K - 1, 0), 0)
print(result)

Fixed submission:
result = 0
N, K = list(map(int , input().split()))
for b in range(K + 1, N + 1):
    result += (N // b) * (b - K) + max(N - (N // b) * b - max(K - 1, 0), 0)
print(result)

Buggy python submission (verdict: Time Limit Exceeded):
cnt = 0
N, K = list(map(int , input().split()))

for x in range(1, N+1):
    for y in range(1, N+1):
        if x%y >=K:
            cnt += 1

print(cnt)

Fixed submission:
result = 0
N, K = list(map(int , input().split()))
for b in range(K + 1, N + 1):
    result += (N // b) * (b - K) + max(N - (N // b) * b - max(K - 1, 0), 0)
print(result)
Buggy python submission (verdict: Runtime Error):
H, W = map(int, input().split())
s = np.array([list(input()) for _ in range(H)])
s = np.pad(s, 1, "constant")
white = (s == ".").sum()
q = [(0, 1, 1)]

goal = False
s[1][1] = '#'
while q:
    d, x, y = q.pop(0)
    if x ==H and y == W :
        print(white - (d + 1))
        goal = True
    for dx, dy in [[0,1], [0, -1], [1,0], [-1,0]]:
        x = x + dx
        y = y + dy
        if s[x][y] == '.':
            s[x][y] = '#'
            q.append((d+1, x, y))
if not goal:
    print(-1)

Fixed submission:
H, W = map(int,input().split())
s = []
black = 0
for i in range(H):
    tmp = list(input())
    s.append(tmp)
    for j in range(W):
        if tmp[j] == "#":
            black += 1
white = H*W - black
 
 
q = [(0,0,0)]
s[0][0] = "#"
while q:
    i, j, cnt = q.pop(0)
    for di, dj in [(1,0),(0,1),(-1,0),(0,-1)]:
        ni, nj = i+di, j+dj
        if ni == H-1 and nj == W-1:
            print(white-cnt-2)
            exit(0)
        elif 0 <= ni < H and 0 <= nj < W and s[ni][nj] == ".":
            s[ni][nj] = "#"
            q.append((ni,nj,cnt+1))
print(-1)

Buggy python submission (verdict: Runtime Error):
H, W = map(int, input().split())
s = np.array([list(input()) for _ in range(H)])
s = np.pad(s, 1, "constant")
white = (s == ".").sum()
q = [(0, 1, 1)]

while q:
    d, x, y = q.pop(0)
    if x ==H and y == W :
        print(white - (d + 1))
        exit()
    for dx, dy in [[0,1], [0, -1], [1,0], [-1,0]]:
        x = x + dx
        y = y + dy
        if s[x][y] == '.':
            s[x][y] = '#'
            q.append((d+1, x, y))
print(-1)

Fixed submission:
H, W = map(int,input().split())
s = []
black = 0
for i in range(H):
    tmp = list(input())
    s.append(tmp)
    for j in range(W):
        if tmp[j] == "#":
            black += 1
white = H*W - black
 
 
q = [(0,0,0)]
s[0][0] = "#"
while q:
    i, j, cnt = q.pop(0)
    for di, dj in [(1,0),(0,1),(-1,0),(0,-1)]:
        ni, nj = i+di, j+dj
        if ni == H-1 and nj == W-1:
            print(white-cnt-2)
            exit(0)
        elif 0 <= ni < H and 0 <= nj < W and s[ni][nj] == ".":
            s[ni][nj] = "#"
            q.append((ni,nj,cnt+1))
print(-1)
Buggy python submission (verdict: Runtime Error):
N = int(input())
a1 = list(map(int, input().split(' ')))
a2 = list(map(int, input().split(' ')))
count = np.zeros(N)
a = np.array([a1,a2])
for i in range(N):
    count[i] += a.T[i].sum()
    count[i] += a[0][:i-1].sum() if i-1 >=0 else 0
    count[i] += a[1][i:].sum()
print(int(count.max())

Fixed submission:
import numpy as np

N = int(input())
a1 = list(map(int, input().split(' ')))
a2 = list(map(int, input().split(' ')))
count = np.zeros(N)
a = np.array([a1,a2])
for i in range(N):
    count[i] += a.T[i].sum()
    count[i] += a[0][:i].sum()
    count[i] += a[1][i+1:].sum() if i+1 < N else 0
print(int(count.max()))
Buggy python submission (verdict: Runtime Error):
import fractions
from functools import reduce


def lcm_list(numbers):
    return reduce(fractions.lcm, numbers)

N = int(input())

t = []
for _ in range(N):
  t.append(int(input()))

print(lcm_list(t))

Fixed submission:
import fractions
from functools import reduce
 
  
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
  
def lcm_list(numbers):
    return reduce(lcm, numbers)
 
N = int(input())
 
t = []
for _ in range(N):
  t.append(int(input()))
 
print(lcm_list(t))
Buggy python submission (verdict: Runtime Error):
a, b = input()

if a == b:
  print('H')
else:
  print('D')

Fixed submission:
a, b = input().split()

if a == b:
  print('H')
else:
  print('D')

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

if a == b:
  print('H')
else:
  print('D')

Fixed submission:
a, b = input().split()

if a == b:
  print('H')
else:
  print('D')
Buggy python submission (verdict: Runtime Error):
N, M = list(map(int, input().split()))

g = [[] for _ in range(N)]

for i in range(N):
  a, b = list(map(int, input().split()))
  g[a-1].append(b-1)
  g[b-1].append(a-1)

visited = [False for _ in range(N)]

def dfs(v, visited):
  if all(visited):
    return 1
  total = 0
  for cv in g[v]:
    if not visited[cv]:
      visited[cv] = True
      total += dfs(v, visited)
      visited[cv] = False
  return total
    
visited[0] = True
ret = dfs(0, visited)
print(ret)
  

Fixed submission:
import itertools
 
N, M = map(int, input().split())
graph = [[0] * N for i in range(N)]
for i in range(M):
    a, b = map(int, input().split())
    graph[a-1][b-1] = 1
    graph[b-1][a-1] = 1
 
p = list(itertools.permutations(range(N)))
 
Sum = 0
 
for i in range(len(p)):
    if p[i][0] != 0:
        break
    for j in range(N - 1):
        if graph[p[i][j]][p[i][j + 1]] != 1:
            break
        elif j == N - 2:
            Sum += 1
 
print(Sum)
Buggy python submission (verdict: Runtime Error):
import math

N = input().split()

A = int(N[0])
B = int(N[1])

lcm = int(A * B / math.gcd(A, B))

print(lcm)


Fixed submission:
from fractions import gcd

N = input().split()

A = int(N[0])
B = int(N[1])

lcm = int(A * B / gcd(A, B))

print(lcm)

Buggy python submission (verdict: Runtime Error):
import math

N = input().split()

lcm = int(N[0]) * int(N[1]) / math.gcd(int(N[0]), int(N[1]))

print(int(lcm))


Fixed submission:
from fractions import gcd

N = input().split()

A = int(N[0])
B = int(N[1])

lcm = int(A * B / gcd(A, B))

print(lcm)
Buggy python submission (verdict: Runtime Error):
pr = int(input())
li =[]

for i in range(pr):
    li.append(int(input))

disc = max(li)

print(sum(li) - disc)

Fixed submission:
pr = int(input())
li =[]

for i in range(pr):
    li.append(int(input()))

disc = max(li) // 2

print(sum(li) - disc)
Buggy python submission (verdict: Runtime Error):
k = input()
a, b = list(map(int, input().split()))
isYes = False
for i in range(a, b+1):
    if i % k == 0:
        isYes = True
        break
print('OK' if isYes else 'NG')

Fixed submission:
k = int(input())
a, b = list(map(int, input().split()))
isYes = False
for i in range(a, b+1):
    if i % k == 0:
        isYes = True
        break
print('OK' if isYes else 'NG')

Buggy python submission (verdict: Runtime Error):
k = input()
a, b = list(map(int, input().split()))
isYes = False
for i in range(a, b+1):
    if i % k == 0:
        isYes = False
        break
print('OK' if isYes else 'NG')

Fixed submission:
k = int(input())
a, b = list(map(int, input().split()))
isYes = False
for i in range(a, b+1):
    if i % k == 0:
        isYes = True
        break
print('OK' if isYes else 'NG')
Buggy python submission (verdict: Runtime Error):
n = input()
print('Yes' if 7 in n else 'No')

Fixed submission:
n = input()
print('Yes' if '7' in n else 'No')
Buggy python submission (verdict: Runtime Error):
a, b, c = input().split()
print(c + ' ' + a + ' '

Fixed submission:
a, b, c = input().split()
print(c + ' ' + a + ' ' + b)

Buggy python submission (verdict: Runtime Error):
a, b, c = input().split()
print(f'{c} {a} {b}')

Fixed submission:
a, b, c = input().split()
print(c + ' ' + a + ' ' + b)
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
import math
import fractions

a, b, n = [int(x) for x in stdin.readline().rstrip().split()]

r = -100
for i in range(b):
    if (i > n):
        break
    if (r < (a * i / b)):
        r = a * i / b

print(int(r))

Fixed submission:
from sys import stdin
import math
import fractions

a, b, n = [int(x) for x in stdin.readline().rstrip().split()]

if (b > n):
    print(int(a * n / b))
else:
    print(int(a * (b - 1) / b))
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
import math
import fractions

n = int(stdin.readline().rstrip())

cnt = 0
for i in range(n):
    for j in range(n):
        for k in range(n):
            a = math.gcd(i+1, j+1)
            b = math.gcd(a, k+1)
            cnt += b

print(cnt)

Fixed submission:
from sys import stdin
import math
import fractions

n = int(stdin.readline().rstrip())

cnt = 0
for i in range(1, n+1):
    for j in range(i, n+1):
        for k in range(j, n+1):
            a = math.gcd(i, j)
            b = math.gcd(a, k) * 6
            if i == j and j == k:
                b = int(b/6)
            elif i == j or j == k or i == k:
                b = int(b/2)
            #print(str(i) + ' ' + str(j) + ' ' + str(k) + ' : ' + str(b))
            cnt += b

print(cnt)
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin

n = int(stdin.readline().rstrip())
s = []
d = [0] * 200000 
max = 1

for i in range(n):
    t = stdin.readline().rstrip()
    d[i] = 1
    for ss in s:
        if t == ss:
            d[i] = d[i] + 1
            if max < d[i]:
                max = d[i]
    s.append(t)

result = []        
for cnt in range(len(d)):
    if d[cnt] == max:
        result.append(s[cnt])

result.sort()
for r in result:
    print(r)


Fixed submission:
from sys import stdin
import math

n = int(stdin.readline().rstrip())

d = {}
max = 0
for i in range(n):
    s = stdin.readline().rstrip()
    if s in d.keys():
        d[s] += 1
    else:
        d[s] = 1
    if max < d[s]:
        max = d[s]

result = []
for key, value in d.items():
    if value == max:
        result.append(key)

result.sort()

for i in range(len(result)):
    print(result[i])
Buggy python submission (verdict: Runtime Error):
from sys import stdin

n = int(stdin.readline().rstrip())
d = [int(x) for x in stdin.readline().rstrip().split()]

m = [0] * 1000000000

for i in d:
    m[i] += 1

result = 0
for i in m:
    if (i > 1):
        result += 1

if (result > 0):
    print("No")
else:
    print("Yes")

Fixed submission:
from sys import stdin
import math

n = int(stdin.readline().rstrip())
a = [int(x) for x in stdin.readline().rstrip().split()]

d = {}
for aa in a:
    if aa in d.keys():
        d[aa] += 1
    else:
        d[aa] = 1

result = 'YES'
for key, value in d.items():
    if value > 1:
        result = 'NO'

print(result)

Buggy python submission (verdict: Runtime Error):
from sys import stdin

n = int(stdin.readline().rstrip())
d = [int(x) for x in stdin.readline().rstrip().split()]

m = [0] * 100

for i in d:
    m[i] += 1

result = 0
for i in m:
    if (i > 1):
        result += 1

if (result > 0):
    print("No")
else:
    print("Yes")

Fixed submission:
from sys import stdin
import math

n = int(stdin.readline().rstrip())
a = [int(x) for x in stdin.readline().rstrip().split()]

d = {}
for aa in a:
    if aa in d.keys():
        d[aa] += 1
    else:
        d[aa] = 1

result = 'YES'
for key, value in d.items():
    if value > 1:
        result = 'NO'

print(result)

Buggy python submission (verdict: Runtime Error):
from sys import stdin

n = int(stdin.readline().rstrip())
d = [int(x) for x in stdin.readline().rstrip().split()]

m = [0] * 100

for i in d:
    m[i] += 1

for i in m:
    if (i > 1):
        print("No")
    else:
        print("Yes")

Fixed submission:
from sys import stdin
import math

n = int(stdin.readline().rstrip())
a = [int(x) for x in stdin.readline().rstrip().split()]

d = {}
for aa in a:
    if aa in d.keys():
        d[aa] += 1
    else:
        d[aa] = 1

result = 'YES'
for key, value in d.items():
    if value > 1:
        result = 'NO'

print(result)
Buggy python submission (verdict: Runtime Error):
from sys import stdin
import math

a, b = [int(x) for x in stdin.readline().rstrip().split()]

print(int(a * b / math.gcd(a, b)))

Fixed submission:
from sys import stdin
import math
import fractions

a, b = [int(x) for x in stdin.readline().rstrip().split()]

print(int(a * b / fractions.gcd(a, b)))
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
import math
import fractions

n, m = [int(x) for x in stdin.readline().rstrip().split()]
a = [int(x) for x in stdin.readline().rstrip().split()]

a.sort(reverse=True)

for i in range(m):
    a[0] = int(a[0]/2)
    a.sort(reverse=True)

print(sum(a))

Fixed submission:
from sys import stdin
import math
import fractions
import heapq

n, m = [int(x) for x in stdin.readline().rstrip().split()]
a = [int(x) for x in stdin.readline().rstrip().split()]

a = list(map(lambda x: x*(-1), a))
heapq.heapify(a)

for i in range(m):
    t = heapq.heappop(a)
    heapq.heappush(a, (-1)*(-t//2))

print(-sum(a))
Buggy python submission (verdict: Time Limit Exceeded):
from sys import stdin
import math
import fractions
import heapq

n = int(stdin.readline().rstrip())

cnt = 0
for i in range(n):
    cnt += i;

print(cnt)

Fixed submission:
from sys import stdin
import math
import fractions
import heapq

n = int(stdin.readline().rstrip())

cnt = n * (n-1) // 2

print(cnt)
Buggy python submission (verdict: Runtime Error):
N = int(input())
M = int(input())
X = int(input())
Y = int(input())

x = [input() for i in range(N)]
y = [input() for i in range(M)]

x.sort(reverse=True)
y.sort()

if x[0] < y[0]:
    print("No War")
else:
    print("War")

Fixed submission:
N, M, X, Y = list(map(int, input().split()))

x = list(map(int, input().split()))
y = list(map(int, input().split()))

x.append(X)
y.append(Y)

x.sort(reverse=True)
y.sort()

if x[0] < y[0]:
    print("No War")
else:
    print("War")
Buggy python submission (verdict: Time Limit Exceeded):
import sys

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


max_ = 0
pred = 0
for i in range(n+1):
    ans_ = int(a*i/b) - a*int(i/b)
    if max_ <= ans_:
        max_ = ans_
    if ans_ < pred:
        print(pred)
        sys.exit()
    pred = ans_
print(max_)

Fixed submission:
import math

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

def calc(x):
    return math.floor(a*x/b) - a* math.floor(x/b)

if n <= (b-1):
    print(calc(n))
else:
    print(calc(b-1))
Buggy python submission (verdict: Time Limit Exceeded):
n, x, y = map(int,input().split())

ans_list = [0]*(n)
for i in range(1, n+1):
    for j in range(1, n+1):
        if i>j:
            min_dis = min(abs(j-i), abs(x-i) + 1 + abs(j-y), abs(y-i)+1+abs(j-x))
            ans_list[min_dis] += 1

for i in range(1, len(ans_list)):
    print(ans_list[i])

Fixed submission:
n, x, y = map(int,input().split())

ans_list = [0]*(n)
for i in range(1, n+1):
    for j in range(i+1, n+1):
            min_dis = min(abs(j-i), abs(x-i) + 1 + abs(j-y), abs(y-i)+1+abs(j-x))
            ans_list[min_dis] += 1

for i in range(1, len(ans_list)):
    print(ans_list[i])
Buggy python submission (verdict: Runtime Error):
from collections import Counter
import math

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

# a =< x < a + 1:
min_a = math.ceil(a/0.08)

max_a = (a+1)/0.08

min_b = math.ceil(b/0.10)

max_b = (b+1)/0.10

ans_list = []

flag = True

while(min_a =< max_a):
    ans_list.append(min_a)
    min_a += 1
while(min_b =< max_b):
    ans_list.append(min_b)
    min_b += 1
ans_list.sort()
ans = Counter(ans_list)
for i in ans:
    if ans[i] > 1:
        print(i)
        flag = False
        break
if flag:
    print(-1)

Fixed submission:
import math

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

ans =  -1

for i in range(2000):
    if math.floor(i * 0.08) == a and math.floor(i * 0.10) == b:
        ans = i
        break

print(ans)

Buggy python submission (verdict: Runtime Error):
from collections import Counter

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

# a =< x < a + 1:
min_a = int(a/0.08)

max_a = int((a+1)/0.08)

min_b = int(b/0.10)

max_b = int((b+1)/0.10)

ans_list = []

while(min_a < max_a):
    ans_list.append(min_a)
    min_a += 1
while(min_b < max_b):
    ans_list.append(min_b)
    min_b += 1
ans_list.sort()
ans = Counter(ans_list)
for i in ans:
    if ans[i] > 1:
        print(i)
        flag = False
        break
if flag:
    print(-1)

Fixed submission:
import math

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

ans =  -1

for i in range(2000):
    if math.floor(i * 0.08) == a and math.floor(i * 0.10) == b:
        ans = i
        break

print(ans)
Buggy python submission (verdict: Runtime Error):
a,b=map(int,input().split())

if (500*a => b):
  print("Yes")
else:
  print("No")

Fixed submission:
a,b=map(int,input().split())
 
if (500*a >= b):
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
a = str(input())

if a == "SUN":
  print("7")
elif a == "MON":
  print("6")
elif a == "TUE":
  print("5")
elif a == "WED":
  print("4")
elif a == "THU":
  print("3")
elif a == "FRI":
  print("2")
else:
  print("1")

SUN,MON,TUE,WED,THU,FRI,SAT

Fixed submission:
a = str(input())

if a == "SUN":
  print("7")
elif a == "MON":
  print("6")
elif a == "TUE":
  print("5")
elif a == "WED":
  print("4")
elif a == "THU":
  print("3")
elif a == "FRI":
  print("2")
else:
  print("1")
Buggy python submission (verdict: Runtime Error):
a = input()

print(a**2)

Fixed submission:
a = int(input())

print(a**2)
Buggy python submission (verdict: Runtime Error):
a = int(input())

s = string(input())

if a % 2 == 1:
  print("No")
else:
  b = int(a/2)
  if s[:b] == s[b:]:
    print("Yes")
  else:
    print("No")

Fixed submission:
a = int(input())

s = str(input())

if a % 2 == 1:
  print("No")
else:
  b = int(a/2)
  if s[:b] == s[b:]:
    print("Yes")
  else:
    print("No")

Buggy python submission (verdict: Runtime Error):
a = int(input())

s = string(input())

if a % 2 == 1:
  print("No")
else:
  b = a/2
  if s[:b] == s[b:]:
    print("Yes")
  else:
    print("No")

Fixed submission:
a = int(input())

s = str(input())

if a % 2 == 1:
  print("No")
else:
  b = int(a/2)
  if s[:b] == s[b:]:
    print("Yes")
  else:
    print("No")
Buggy python submission (verdict: Runtime Error):
a = int(input())
flag = 0

for i in range(8):
  if a % (i+2) == 0:
    flag = 1

if flag = 1:
  print("Yes")
else:
  print("No")


Fixed submission:
a = int(input())
flag = 0

for i in range(9):
  for j in range(9):
    if (i+1)*(j+1) == a:
      flag = 1

if flag == 1:
	print("Yes")
else:
	print("No")