Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
n,m = map(int,input().split())
p_list = [input().split() for i in range(m)]

ans_list = [[[0] for i in range(2)] for j in range(n)]
#print(ans_list[0])
for i in range(m):
    p_num = int(p_list[i][0])
    if p_list[i][1] == "WA":
        ans_list[p_num-1][1]  = 1
    else:
        ans_list[p_num-1][0]  = 1
count1 = 0
count2 = 0
for i in range(n):
    if ans_list[i][0] == 1:
        count += 1
        if ans_list[i][1] == 1:
            count2 += 1
print(count1,count2)


Fixed submission:
n,m = map(int,input().split())
p_list = [input().split() for i in range(m)]

ans_list = [[0 for i in range(2)] for j in range(n)]
#print(ans_list[0])
for i in range(m):
    p_num = int(p_list[i][0])
    if ans_list[p_num-1][0] != 1:
        if p_list[i][1] == "WA":
            ans_list[p_num-1][1]  =  ans_list[p_num-1][1] + 1
        else:
            ans_list[p_num-1][0]  = 1
count1 = 0
count2 = 0
for i in range(n):
    if ans_list[i][0] == 1:
        count1 += 1
        count2 += ans_list[i][1]
print(count1,count2)
Buggy python submission (verdict: Runtime Error):
n = int(input())
s = input()
count = 0
for i in range(n):
  if s[i] == "A":
    if s[i+1]+s[i+2] == "BC":
      count += 1
print(count)

Fixed submission:
n = int(input())
s = input()
count = 0
for i in range(n-2):
  if s[i] == "A":
    if s[i+1]+s[i+2] == "BC":
      count += 1
print(count)
Buggy python submission (verdict: Runtime Error):
from math import gcd
a,b = map(int,input().split())
print(a*b//gcd(a,b))

Fixed submission:
import fractions
a,b = map(int,input().split())
print(a*b//fractions.gcd(a,b))
Buggy python submission (verdict: Runtime Error):
a = input().split
b = input().split

if a[0] = b[0]:
  print("0")
else:
  print("1")

Fixed submission:
a = []
b = []
a = input().split()
b = input().split()

if a[0] == b[0]:
  print("0")
else:
  print("1")
Buggy python submission (verdict: Runtime Error):
n = int(input())
s = input()
dum1,dum2 = divmod(n,2)
flag = "ok"
if dum2 != 0:
  print("No")
else:
  for i in range(dum1):
    if s[i] != s[i+3]:
      flag = "ng"
      break
  if flag == "ng":
    print("No")
  else:
    print("Yes")

Fixed submission:
n = int(input())
s = input()
dum1,dum2 = divmod(n,2)
flag = "ok"
if dum2 != 0:
  print("No")
else:
  for i in range(dum1):
    if s[i] != s[i+dum1]:
      flag = "ng"
      break
  if flag == "ng":
    print("No")
  else:
    print("Yes")
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
l_li = list(map(int,input().split()))
l_li.sort()
ans = 0
for i in range(n-2):
    for j in range(i+1,n-1):
        for k in range(j+1,n):
            if l_li[k] >= l_li[i]+l_li[j]:
                break
            if l_li[i] < l_li[j]+l_li[k] and l_li[j] < l_li[i]+l_li[k] and l_li[k] < l_li[i]+l_li[j]:
                ans += 1
print(ans)

Fixed submission:
import bisect
n = int(input())
l_li = list(map(int,input().split()))
l_li.sort()
ans = 0
for i in range(n-2):
    for j in range(i+1,n-1):
        ind = bisect.bisect_left(l_li,l_li[i]+l_li[j])
        num = ind-1 - j
        if num > 0:
            ans += num
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
l_li = list(map(int,input().split()))
ans = 0
for i in range(n-2):
    for j in range(i+1,n-1):
        for k in range(j+1,n):
            if l_li[i] < l_li[j]+l_li[k] and l_li[j] < l_li[i]+l_li[k] and l_li[k] < l_li[i]+l_li[j]:
                ans += 1
print(ans)

Fixed submission:
import bisect
n = int(input())
l_li = list(map(int,input().split()))
l_li.sort()
ans = 0
for i in range(n-2):
    for j in range(i+1,n-1):
        ind = bisect.bisect_left(l_li,l_li[i]+l_li[j])
        num = ind-1 - j
        if num > 0:
            ans += num
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a_list = list(map(int,input().split()))
for i in range(n):
    a_list[i] = [a_list[i],str(i+1)]
a_list.sort()
ans = ""
for i in range(n):
    ans += a_list[i][1] + " "
print(ans)

Fixed submission:
n = int(input())
a_list = list(map(int,input().split()))
ans = [0]*n
for i in range(n):
    ans[a_list[i]-1] = i+1
print(" ".join(map(str,ans)))

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a_list = list(map(int,input().split()))
for i in range(n):
    a_list[i] = [a_list[i],i+1]
a_list.sort()
ans = ""
for i in range(n):
    ans += str(a_list[i][1]) + " "
print(ans)

Fixed submission:
n = int(input())
a_list = list(map(int,input().split()))
ans = [0]*n
for i in range(n):
    ans[a_list[i]-1] = i+1
print(" ".join(map(str,ans)))
Buggy python submission (verdict: Runtime Error):
a = int(input())
num_list = list(map(int,input().split()))
flag = ""
for i in range(a-1):
  if num_list[i]-1 <= num_list[i+1]:
    flag = "ok"
  else:
    flag = "ng"
if flag = "ok":
  print("Yes")
else:
  print("No")


Fixed submission:
from collections import Counter
a = int(input())
num_list = list(map(int,input().split()))
flag = "ok"
num_o = 0
for i in range(a-1):
  if num_list[i] > num_o:
    num_list[i] = num_list[i]-1
    num_o = num_list[i]
  if num_list[i]-num_list[i+1] > 0:
    flag = "ng"
    break

num_counter = Counter(num_list)
num_most = num_counter.most_common()
#if a == num_most[0][1] and a != 0:
#  flag = "No"
if flag == "ok":
  print("Yes")
else:
  print("No")

Buggy python submission (verdict: Runtime Error):
a = int(input))
num_list = list(map(int,input().split()))
flag = ""
for i in range(a-1):
  if num_list[i]-1 <= num_list[i+1]:
    flag = "ok"
  else:
    flag = "ng"
if flag = "ok":
  print("Yes")
else:
  print("No")

Fixed submission:
from collections import Counter
a = int(input())
num_list = list(map(int,input().split()))
flag = "ok"
num_o = 0
for i in range(a-1):
  if num_list[i] > num_o:
    num_list[i] = num_list[i]-1
    num_o = num_list[i]
  if num_list[i]-num_list[i+1] > 0:
    flag = "ng"
    break

num_counter = Counter(num_list)
num_most = num_counter.most_common()
#if a == num_most[0][1] and a != 0:
#  flag = "No"
if flag == "ok":
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Time Limit Exceeded):
s = input()
mass = [1] * len(s)
mass_o = mass
cnt = 0
while(1):
    cnt += 1
    mass_dum = [0] * len(s)
    for i in range(len(s)):
        if mass[i] > 0:
            if s[i] == "R":
                mass_dum[i + 1] += mass[i]
            else:
                mass_dum[i - 1] += mass[i]
    mass = mass_dum
    if mass == mass_o:
        break
    if cnt % 2 == 0:
        mass_o = mass

if cnt % 2 != 0:
    mass_dum = [0] * len(s)
    for i in range(len(s)):
        if mass[i] > 0:
            if s[i] == "R":
                mass_dum[i + 1] += mass[i]
            else:
                mass_dum[i - 1] += mass[i]
    mass = mass_dum
print(" ".join(map(str,mass)))


Fixed submission:
s = input()
cons = 0
ans = [0]*(len(s))
left = 0
right = 0
check1 = True
check2 = False
for i in range(len(s)):
    if check1 == True and s[i] == "L":
        cons = i
        check1 = False
        check2 = True
    if check2 == True and (s[i] == "R" or i == len(s)-1):
        right = i-1
        if i == len(s)-1:
            right += 1
        dum = s[left:right+1]
        dum_index = dum.index("L")
        dum_len = len(dum)
        div,mod = divmod(dum_len,2)
        if dum_index%2 == 0:
            ans[cons] = div+mod
            ans[cons-1] = div
        else:
            ans[cons] = div
            ans[cons-1] = div+mod

        check1 = True
        check2 = False
        left = right+1
print(" ".join(map(str,ans)))

Buggy python submission (verdict: Time Limit Exceeded):
s = input()
mass = [1] * len(s)
mass_o = mass
cnt = 0
while(1):
    cnt += 1
    mass_dum = [0] * len(s)
    for i in range(len(s)):
        if mass[i] > 0:
            if s[i] == "R":
                mass_dum[i + 1] += mass[i]
            else:
                mass_dum[i - 1] += mass[i]
    mass = mass_dum
    if mass == mass_o:
        break
    if cnt % 2 == 0:
        mass_o = mass

if cnt % 2 != 0:
    mass_dum = [0] * len(s)
    for i in range(len(s)):
        if mass[i] > 0:
            if s[i] == "R":
                mass_dum[i + 1] += mass[i]
            else:
                mass_dum[i - 1] += mass[i]
    mass = mass_dum
print(" ".join(map(str,mass)))


Fixed submission:
s = input()
cons = 0
ans = [0]*(len(s))
left = 0
right = 0
check1 = True
check2 = False
for i in range(len(s)):
    if check1 == True and s[i] == "L":
        cons = i
        check1 = False
        check2 = True
    if check2 == True and (s[i] == "R" or i == len(s)-1):
        right = i-1
        if i == len(s)-1:
            right += 1
        dum = s[left:right+1]
        dum_index = dum.index("L")
        dum_len = len(dum)
        div,mod = divmod(dum_len,2)
        if dum_index%2 == 0:
            ans[cons] = div+mod
            ans[cons-1] = div
        else:
            ans[cons] = div
            ans[cons-1] = div+mod

        check1 = True
        check2 = False
        left = right+1
print(" ".join(map(str,ans)))
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a_list = [int(input()) for i in range(n)]
for i in range(n):
    dum = a_list[i]
    a_list[i] = 0
    print(max(a_list))
    a_list[i] = dum


Fixed submission:
n = int(input())
a_list = [int(input()) for i in range(n)]
a_list_sort = sorted(a_list)
a_list_max1 = max(a_list)
a_list_max2 = a_list_sort[-2]
for i in range(n):
    if a_list_max1 == a_list[i]:
        print(a_list_max2)
    else:
        print(a_list_max1)
Buggy python submission (verdict: Runtime Error):
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
a_counter = Counter(a)
k = list(a_counter.keys())
v = list(a_counter.values())

if len(a_counter) == 3 and k[0]^k[1]^k[2] == 0 and v[0] == v[1] == v[2]:
    print("Yes")
elif len(a_counter) == 2 and 0 in k and v[0] == v[1]*2 or v[1] == v[0]*2:
    print("Yes")
elif len(a_counter) == 1 and 0 in k:
    print("Yes")
else:
    print("No")

Fixed submission:
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
a_counter = Counter(a)
a_counter_li = list(a_counter)
if sum(a) == 0:
    print("Yes")
elif len(a)%3 != 0:
    print("No")
elif len(a_counter) > 3 or len(a_counter) <= 1:
    print("No")
elif len(a_counter) == 3:
    if a_counter[a_counter_li[0]] == n // 3 and a_counter[a_counter_li[1]] == n // 3 and a_counter[a_counter_li[2]] == n // 3:
        if a_counter_li[0]^a_counter_li[1]^a_counter_li[2] == 0:
            print("Yes")
        else:
            print('No')
    else:
        print("No")
else:
    a_counter_li.sort()
    if a_counter_li[0] == 0 and a_counter[a_counter_li[0]] == n // 3:
        print("Yes")
    else:
        print("No")

Buggy python submission (verdict: Runtime Error):
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
a_counter = Counter(a)
k = list(a_counter.keys())
v = list(a_counter.values())

if len(k) == 3 and k[0]^k[1]^k[2] == 0 and v[0] == v[1] == v[2]:
    print("Yes")
elif len(k) == 2 and 0 in k and v[0] == v[1]*2 or v[1] == v[0]*2:
    print("Yes")
elif len(k) == 1 and 0 in k :
    print("Yes")
else:
    print("No")

Fixed submission:
from collections import Counter
n = int(input())
a = list(map(int,input().split()))
a_counter = Counter(a)
a_counter_li = list(a_counter)
if sum(a) == 0:
    print("Yes")
elif len(a)%3 != 0:
    print("No")
elif len(a_counter) > 3 or len(a_counter) <= 1:
    print("No")
elif len(a_counter) == 3:
    if a_counter[a_counter_li[0]] == n // 3 and a_counter[a_counter_li[1]] == n // 3 and a_counter[a_counter_li[2]] == n // 3:
        if a_counter_li[0]^a_counter_li[1]^a_counter_li[2] == 0:
            print("Yes")
        else:
            print('No')
    else:
        print("No")
else:
    a_counter_li.sort()
    if a_counter_li[0] == 0 and a_counter[a_counter_li[0]] == n // 3:
        print("Yes")
    else:
        print("No")
Buggy python submission (verdict: Runtime Error):
l,r = map(int,input().split())
if r - l >= 2019:
    print(0)
else:
    ans_o = (l*(l+1))%2019
    for i in range(l,r):
        for j in range(i+1,r+1):
            ans = (i*j)%2019
            ans_o = min(ans,ans_o)
print(ans_o)

Fixed submission:
l,r = map(int,input().split())
if r - l >= 2019:
    print(0)
else:
    ans_o = (l*(l+1))%2019
    for i in range(l,r):
        for j in range(i+1,r+1):
            ans = (i*j)%2019
            ans_o = min(ans,ans_o)
    print(ans_o)

Buggy python submission (verdict: Runtime Error):
l,r = map(int,input().split())
if r - l >= 2019:
    print(0)
else:
    ans_o = (l*(l+1))%2019
    for i in range(l+1,r):
        for j in range(i+1,r+1):
            ans = (i*j)%2019
            ans_o = min(ans,ans_o)
print(ans_o)

Fixed submission:
l,r = map(int,input().split())
if r - l >= 2019:
    print(0)
else:
    ans_o = (l*(l+1))%2019
    for i in range(l,r):
        for j in range(i+1,r+1):
            ans = (i*j)%2019
            ans_o = min(ans,ans_o)
    print(ans_o)
Buggy python submission (verdict: Runtime Error):
import math
a,b,c,d = map(int,input().split())
#c_d = math.floor(((c*d)//(math.gcd(c,d))))
c_d = (c*d)//(math.gcd(c,d))
#print((math.gcd(c,d)))
a_c = (a-1) // c
a_d = (a-1) // d
a_c_d = (a-1) // c_d
a_ans = (a-1) - a_c - a_d + a_c_d
#ans1 = (a_c + a_d - a_c_d)
#print(c_d)
b_c = b // c
b_d = b // d
b_c_d = b // c_d
b_ans = b - b_c - b_d + b_c_d
#ans2 = (b_c + b_d -b_c_d)
#print(ans2)
#print(math.floor((b-a+1)-(ans2-ans1)))
print(math.floor(b_ans-a_ans))

Fixed submission:
import math
import fractions
a,b,c,d = map(int,input().split())
#c_d = math.floor(((c*d)//(math.gcd(c,d))))
c_d = (c*d)//(fractions.gcd(c,d))
#print((math.gcd(c,d)))
a_c = (a-1) // c
a_d = (a-1) // d
a_c_d = (a-1) // c_d
a_ans = (a-1) - a_c - a_d + a_c_d
#ans1 = (a_c + a_d - a_c_d)
#print(c_d)
b_c = b // c
b_d = b // d
b_c_d = b // c_d
b_ans = b - b_c - b_d + b_c_d
#ans2 = (b_c + b_d -b_c_d)
#print(ans2)
#print(math.floor((b-a+1)-(ans2-ans1)))
print(math.floor(b_ans-a_ans))
Buggy python submission (verdict: Runtime Error):
s = input()
a = int(s[0:2])
b = int(s[2:4])
if 0 < a <= 12 and 0 < b <= 12:
    print("AMBIGUOUS")
elif (a > 12 and b > 12) or a == 0 or b == 0:
    print("NA")
elif a > 12:
    print("YYMM")
elif b > 12
    print("MMYY")

Fixed submission:
s = input()
a = int(s[0:2])
b = int(s[2:4])
if 0 < a <= 12 and 0 < b <= 12:
    print("AMBIGUOUS")
elif (a == 0 or a > 12) and 0 < b <= 12:
    print("YYMM")
elif (b == 0 or b > 12) and 0 < a <= 12:
    print("MMYY")
else:
    print("NA")
Buggy python submission (verdict: Runtime Error):
a,b = mmap(int,input().split())
print(a-b+1)


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

Buggy python submission (verdict: Runtime Error):
a,b = int(input())
print(a-b+1)

Fixed submission:
a,b = map(int,input().split())
print(a-b+1)
Buggy python submission (verdict: Runtime Error):
n_list = list(input())
n_len_o = len(n_list)
#print(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i,i+1)
      if a != 0:
        a = i - 1
      flag = "ok"
      break
  if flag == "ng":
    break
print(n_len_o-len(n_list))

Fixed submission:
n_list = list(input())
n_len_o = len(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      if i != 0:
        a = i - 1
      else:
        a = 0
      flag = "ok"
      break
  if flag == "ng":
    break
print(n_len_o-len(n_list))

Buggy python submission (verdict: Time Limit Exceeded):
n_list = list(input())
n_len_o = len(n_list)
#print(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      if a != 0:
        a = i - 1
      else:
        a = 0
      flag = "ok"
      break
  if flag == "ng":
    break
#print(n_list)
print(n_len_o-len(n_list))

Fixed submission:
n_list = list(input())
n_len_o = len(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      if i != 0:
        a = i - 1
      else:
        a = 0
      flag = "ok"
      break
  if flag == "ng":
    break
print(n_len_o-len(n_list))

Buggy python submission (verdict: Runtime Error):
n_list = list(input())
n_len_o = len(n_list)
#print(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      a = i - 1
      flag = "ok"
      break
  if flag == "ng":
    break
#print(n_list)
print(n_len_o-len(n_list))

Fixed submission:
n_list = list(input())
n_len_o = len(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      if i != 0:
        a = i - 1
      else:
        a = 0
      flag = "ok"
      break
  if flag == "ng":
    break
print(n_len_o-len(n_list))

Buggy python submission (verdict: Time Limit Exceeded):
n_list = list(input())
n_len_o = len(n_list)
#print(n_list)

while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      flag = "ok"
      break
  if flag == "ng":
    break
#print(n_list)
print(n_len_o-len(n_list))

Fixed submission:
n_list = list(input())
n_len_o = len(n_list)
a = 0
while(1):
  flag = "ng"
  n_len = len(n_list)
  for i in range(a,n_len-1):
    if n_list[i] != n_list[i+1]:
      n_list.pop(i)
      n_list.pop(i)
      if i != 0:
        a = i - 1
      else:
        a = 0
      flag = "ok"
      break
  if flag == "ng":
    break
print(n_len_o-len(n_list))
Buggy python submission (verdict: Runtime Error):
a,b = map(int,input().split())
dum1 = min(a,b)
dum2 = max(a,b)
ans = ""
for i in range(dum2):
  ans += str(dum1)
print(ans)

Fixed submission:
s = input()
n = len(s)
if n == 7:
    if s == "keyence":
        print("YES")
    else:
        print("NO")
else:
    if s[n-7:n] == "keyence" or (s[0]+s[n-6:n]) == "keyence" or (s[0:2]+s[n-5:n]) == "keyence" or (s[0:3]+s[n-4:n]) == "keyence" or (s[0:4]+s[n-3:n]) == "keyence" or (s[0:5]+s[n-2:n]) == "keyence" or  (s[0:6]+s[n-1:n]) == "keyence"  or (s[0:7]) == "keyence":
        print("YES")
    else:
        print("NO")
Buggy python submission (verdict: Time Limit Exceeded):
import math
n,p = map(int,input().split())
dum = math.floor(p**(1/n))+1
for i in range(dum,-1,-1):
    if p%(i**n) == 0:
        print(i)
        break

Fixed submission:
n,p = map(int,input().split())
dum = round(p**(1/n))
for i in range(dum,-1,-1):
    if p%(i**n) == 0:
        print(i)
        break

Buggy python submission (verdict: Time Limit Exceeded):
import math
n,p = map(int,input().split())
dum = math.ceil(p**(1/n))
for i in range(dum,-1,-1):
    if p%(i**n) == 0:
        print(i)
        break

Fixed submission:
n,p = map(int,input().split())
dum = round(p**(1/n))
for i in range(dum,-1,-1):
    if p%(i**n) == 0:
        print(i)
        break
Buggy python submission (verdict: Runtime Error):
a,b = int(input())
print(a+(b//2))

Fixed submission:
a,b = map(int,input().split())
print(a+(b//2))
Buggy python submission (verdict: Time Limit Exceeded):
import math
n,m = map(int,input().split())
s = input()
t = input()
lcm = n*m//math.gcd(n,m)
ans = []
for i in range(0,lcm,lcm//n):
    ans.append(i)
for i in range(0,lcm,lcm//m):
    if ans.count(i) == 1:
        if i == 0:
            if s[0] != t[0]:
                print(-1)
                exit()
        if s[i//(lcm//n)] != t[i//(lcm//m)]:
            print(-1)
            exit()
print(lcm)





Fixed submission:
import math
n,m = map(int,input().split())
s = input()
t = input()
lcm = n*m//math.gcd(n,m)
ans = []
s_ind = lcm//n
t_ind = lcm//m
check_ind = s_ind*t_ind//math.gcd(s_ind,t_ind)
for i in range(0,lcm,check_ind):
    if s[i//s_ind] != t[i//t_ind]:
        print(-1)
        exit()
print(lcm)

Buggy python submission (verdict: Runtime Error):
import math
n,m = map(int,input().split())
s = input()
t = input()
lcm = n*m//math.gcd(n,m)
ans = [0]*lcm
for i in range(n):
    ans[i*(lcm)//n] = s[i]
for i in range(m):
    if ans[i*(lcm)//m] != t[i] and 0 != ans[i*(lcm)//m]:
        print(-1)
        exit()
print(lcm)



Fixed submission:
import math
n,m = map(int,input().split())
s = input()
t = input()
lcm = n*m//math.gcd(n,m)
ans = []
s_ind = lcm//n
t_ind = lcm//m
check_ind = s_ind*t_ind//math.gcd(s_ind,t_ind)
for i in range(0,lcm,check_ind):
    if s[i//s_ind] != t[i//t_ind]:
        print(-1)
        exit()
print(lcm)
Buggy python submission (verdict: Runtime Error):
a,b = map(int,input().split())
if a*b%2 == 0:
  print("No")
else:
  ptint("Yes")

Fixed submission:
a,b = map(int,input().split())
if a*b%2 == 0:
  print("No")
else:
  print("Yes")
Buggy python submission (verdict: Runtime Error):
a,b = map(int, input().split)
print((a-1)*(b-1))

Fixed submission:
a,b = map(int, input().split())
print((a-1)*(b-1))
Buggy python submission (verdict: Runtime Error):
import math
a = int(input())
num = math.gcd(2,a)
print(a*2/num)

Fixed submission:
import fractions
a = int(input())
num = fractions.gcd(2,a)
print(a*2//num)
Buggy python submission (verdict: Time Limit Exceeded):
a,b,c,k = map(int,input().split())
if a == b:
    print(0)
    exit()
for i in range(k):
    a_o = a
    b_o = b
    c_o = c
    a = b_o + c_o
    b = a_o + c_o
    c = a_o + b_o
    if abs(a-b) > 10**18:
        print("Unfair")
        break
print(a-b)


Fixed submission:
a,b,c,k = map(int,input().split())
ans = a - b
if k % 2 == 0:
    print(ans)
else:
    print(-ans)

Buggy python submission (verdict: Time Limit Exceeded):
a,b,c,k = map(int,input().split())
if a == b == c:
    print(0)
    exit()
for i in range(k):
    a_o = a
    b_o = b
    c_o = c
    a = b_o + c_o
    b = a_o + c_o
    c = a_o + b_o
    if abs(a-b) > 10**18:
        print("Unfair")
        break
print(a-b)


Fixed submission:
a,b,c,k = map(int,input().split())
ans = a - b
if k % 2 == 0:
    print(ans)
else:
    print(-ans)
Buggy python submission (verdict: Runtime Error):
import math
x = int(input())
for i in range(x,0,-1):
    if math.sqrt(i)%1 == 0  or (math.ceil(i ** (1/3)))**3 == i (math.ceil(i ** (1/5)))**5 == i:
        print(i)
        break

Fixed submission:
import math
x = int(input())
for i in range(x,0,-1):
    if math.sqrt(i)%1 == 0  or (math.ceil(i ** (1/3)))**3 == i or (math.ceil(i ** (1/5)))**5 == i:
        print(i)
        break