Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Time Limit Exceeded):
a, b, k = map(int, input().split())
data = [i for i in range(a, b + 1)]

if k >= -(-len(data)//2):
    for i in data:
        print(i)
else:
    for i in range(k):
        print(data[i])
    for i in range(len(data) - k, len(data)):
        print(data[i])

Fixed submission:
a, b, k = map(int, input().split())
if k >= -(-(b - a + 1)//2):
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(a, a + k):
        print(i)
    for i in range(b + 1 - k, b + 1):
        print(i)

Buggy python submission (verdict: Time Limit Exceeded):
a, b, k = map(int, input().split())
data = [i for i in range(a, b + 1)]

ans = []
if k >= -(-len(data)//2):
    for i in data:
        print(i)
else:
    for i in range(k):
        ans.append(data[i])
    for i in range(len(data) - k, len(data)):
        ans.append(data[i])
    for i in ans:
        print(i)

Fixed submission:
a, b, k = map(int, input().split())
if k >= -(-(b - a + 1)//2):
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(a, a + k):
        print(i)
    for i in range(b + 1 - k, b + 1):
        print(i)

Buggy python submission (verdict: Time Limit Exceeded):
a, b, k = map(int, input().split())
data = [i for i in range(a, b + 1)]

ans = []
if k > len(data):
    for i in data:
        print(i)
else:
    for i in range(k):
        if data[i] not in ans:
            ans.append(data[i])        
    for i in range(len(data) - k, len(data)):
        if data[i] not in ans:
            ans.append(data[i])
    
    for i in ans:
        print(i)

Fixed submission:
a, b, k = map(int, input().split())
if k >= -(-(b - a + 1)//2):
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(a, a + k):
        print(i)
    for i in range(b + 1 - k, b + 1):
        print(i)

Buggy python submission (verdict: Time Limit Exceeded):
a, b, k = map(int, input().split())
data = [i for i in range(a, b + 1)]

ans = []
if k > len(data):
    k = len(data)
for i in range(k):
    if data[i] not in ans:
        ans.append(data[i])
for i in range(len(data) - k, len(data)):
    if data[i] not in ans:
        ans.append(data[i])

for i in ans:
    print(i)

Fixed submission:
a, b, k = map(int, input().split())
if k >= -(-(b - a + 1)//2):
    for i in range(a, b + 1):
        print(i)
else:
    for i in range(a, a + k):
        print(i)
    for i in range(b + 1 - k, b + 1):
        print(i)
Buggy python submission (verdict: Runtime Error):
a, b, c, d = map(int, input().split())
print(min(a, b) + min(c, d))

Fixed submission:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a, b) + min(c, d))
Buggy python submission (verdict: Runtime Error):
N = int(input())

b = {}
for i in range(N):
  s = str(input())
  if b.get(s) is None:
    b[s] = 1
  else:
    b[s] += 1
    
r = {}
for i in range(N):
  s = str(input())
  if r.get(s) is None:
    r[s] = 1
  else:
    r[s] += 1

ans = -999999
for st in b:
  if r.get(st) is None:
    ans = max(ans, b[st])
  else:
    ans = max(ans, b[st] - r[st])
print(ans)
 


Fixed submission:
N = int(input())

b = {}
for i in range(N):
  s = str(input())
  if b.get(s) is None:
    b[s] = 1
  else:
    b[s] += 1
    
r = {}
M = int(input())
for i in range(M):
  s = str(input())
  if r.get(s) is None:
    r[s] = 1
  else:
    r[s] += 1

ans = -999999
for st in b:
  if r.get(st) is None:
    ans = max(ans, b[st])
  else:
    ans = max(ans, b[st] - r[st])
if ans >= 0:
  print(ans)
else:
  print(0)
Buggy python submission (verdict: Runtime Error):
s1 = list(str(iuput()))
s2 = list(str(iuput()))
s3 = list(str(iuput()))
print(s1[0] + s2[1] + s3[2])


Fixed submission:
s1 = list(str(input()))
s2 = list(str(input()))
s3 = list(str(input()))
print(s1[0] + s2[1] + s3[2])
Buggy python submission (verdict: Runtime Error):
n = int(input())
a = int(input())
if (n% 500) <= A:
  print("Yes")
else:
  print("No")

Fixed submission:
n = int(input())
a = int(input())
if (n% 500) <= a:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
N = int(input())
A = list(map(int, input().split()))
A.sort(reversed=True)
alice = 0
bob = 0
for index, a in enumerate(A):
  if (index % 2)  == 0:
    alice += a
  else:
    bob += a
print(alice - bob)

Fixed submission:
N = int(input())
A = list(map(int, input().split()))
A = sorted(A, reverse=True)
alice = 0
bob = 0
for index, a in enumerate(A):
  if (index % 2)  == 0:
    alice += a
  else:
    bob += a
print(alice - bob)
Buggy python submission (verdict: Time Limit Exceeded):
x, y = map(int, input().split())
if x == y:
  print(-1)
else:
  now = x
  k = 1
  M = pow(10, 18)
  while now <= M:
    now = k * now
    if now % y != 0:
      break
  print(now)

Fixed submission:
x, y = map(int, input().split())
if x == y or x % y == 0:
  print(-1)
else:
  now = x
  k = 1
  M = pow(10, 18)
  while now <= M:
    now = k * now
    if now % y != 0:
      break
    k += 1
  print(now)
Buggy python submission (verdict: Runtime Error):
X = int(input())
A = int(input())
B = int(input())

remain = X - A
for i in range(100000):
  if (remain - B) < 0:
    print(ans)
    break
  elif (remain - B) == 0:
    print(0)
    break
  else:
    remain -= B


Fixed submission:
X = int(input())
A = int(input())
B = int(input())
ans = 0
remain = X - A
for i in range(100000):
  if (remain - B) < 0:
    ans = remain
    break
  elif (remain - B) == 0:
    ans = 0
    break
  else:
    remain -= B
print(ans)
Buggy python submission (verdict: Runtime Error):
A = int(input())
B = int(input())
C = int(input())
X = int(input())

ans = 0 
for i in range(0, A + 1):
  numi = i * 500
  if numi == X:
    ans += 1
  elif numi < X:
    for j in range(0, B + 1):
      numj = j * 100 + numi
      if numj == X:
        ans += 1
      elif numj < X:
        for k in range(0, k + 1):
          numk = k * 50 + numj
          if numk == X:
            ans += 1
          elif numk < X:
            continue
          else:
            break
      else:
        break
  else:
    continue
print(ans)

Fixed submission:
A = int(input())
B = int(input())
C = int(input())
X = int(input())

ans = 0 
for i in range(0, A + 1):
  numi = i * 500
  if numi == X:
    ans += 1
  elif numi < X:
    for j in range(0, B + 1):
      numj = j * 100 + numi
      if numj == X:
        ans += 1
      elif numj < X:
        for k in range(0, C + 1):
          numk = k * 50 + numj
          if numk == X:
            ans += 1
          elif numk < X:
            continue
          else:
            break
      else:
        break
  else:
    continue
print(ans)
Buggy python submission (verdict: Runtime Error):
S = list(str(input()))

ans = ''
y = ''

for index, s in enumerate(S):
  y += s
  if index == 3:
    ans = 2018
    break
    
for s in S[4:]:
  ans += s
print(ans)

      

Fixed submission:
S = list(str(input()))

ans = ''
y = ''

for index, s in enumerate(S):
  y += s
  if index == 3:
    ans = '2018'
    break
    
for s in S[4:]:
  ans += s
print(ans)
Buggy python submission (verdict: Runtime Error):
N = int(input())
A = map(int, input().split())
dic = {}
for i in range(N):
  if dic.get(A[i]) is None: 
    dic[A[i]] = 1
  else:
    dic[A[i]] += 1

ans = 0
for k in dic:
  if dic[k] >= k:
    ans += abs(dic[k] - k)
  else:
    ans += dic[k]
print(ans)

Fixed submission:
N = int(input())
A = list(map(int, input().split()))
dic = {}
for i in range(N):
  if dic.get(A[i]) is None: 
    dic[A[i]] = 1
  else:
    dic[A[i]] += 1

ans = 0
for k in dic:
  if dic[k] >= k:
    ans += abs(dic[k] - k)
  else:
    ans += dic[k]
print(ans)

Buggy python submission (verdict: Runtime Error):
N = int(input())
dic = {}
for i in range(N):
  num = int(input())
  if dic.get(num) is None: 
    dic[n] = 1
  else:
    dic[n] += 1

ans = 0
for k in dic:
  if dic[k] >= k:
    ans += abs(dic[k] - k)
  else:
    ans += dic[k]
print(ans)

Fixed submission:
N = int(input())
A = list(map(int, input().split()))
dic = {}
for i in range(N):
  if dic.get(A[i]) is None: 
    dic[A[i]] = 1
  else:
    dic[A[i]] += 1

ans = 0
for k in dic:
  if dic[k] >= k:
    ans += abs(dic[k] - k)
  else:
    ans += dic[k]
print(ans)
Buggy python submission (verdict: Runtime Error):
N = str(input())
L = list(N)
f = 0
for l in L:
  f += l
if (int(N) % f) == 0:
  print("Yes")
else:
  print("No")

Fixed submission:
N = str(input())
L = list(N)
f = 0
for l in L:
  f += int(l)
if (int(N) % f) == 0:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
a,b = map(int, input().split())
if a < b:
  print("<")
elif a == b:
  print("=")
else:
  print(">")

Fixed submission:
a,b = map(str, input().split())
if a < b:
  print("<")
elif a == b:
  print("=")
else:
  print(">")
Buggy python submission (verdict: Runtime Error):
c1,c2 = map(str, input(),split())
c1 = list(c1)[::-1]
c2 = list(c2)
if c1 == c2:
  print("YES")
else:
  print("NO")

Fixed submission:
c1 = str(input())
c2 = str(input())
c1 = list(c1)[::-1]
c2 = list(c2)
if c1 == c2:
  print("YES")
else:
  print("NO")
Buggy python submission (verdict: Runtime Error):
N = int(input())
K = int(input())
dp = [0] * (N+10)
dp[0] = 1
for i in range(1, N):
  dp[i] = min(d[i-1] * 2, d[i-1] + K)
print(dp[N-1])

Fixed submission:
N = int(input())
K = int(input())
dp = [0] * (N+10)
dp[0] = 1
for i in range(1, N+1):
  dp[i] = min(dp[i-1] * 2, dp[i-1] + K)
print(dp[N])
Buggy python submission (verdict: Time Limit Exceeded):
N, M = map(int, input().split())
first = []
second = []
for _ in range(M):
  a, b = map(int, input().split())
  if a == 1:
    first.append(b)
  elif b == N:
    second.append(a)

ans = 0
for i in first:
  if i in second:
    ans = 1
    break
if ans:
  print("POSSIBLE")
else:
  print("IMPOSSIBLE")

Fixed submission:
N, M = map(int, input().split())
first = set()
second = set()
for _ in range(M):
  a, b = map(int, input().split())
  if a == 1:
    first.add(b)
  elif b == N:
    second.add(a)

ans = 0
for i in first:
  if i in second:
    ans = 1
    break
if ans:
  print("POSSIBLE")
else:
  print("IMPOSSIBLE")

Buggy python submission (verdict: Runtime Error):
first = []
second = []
for _ in range(M):
  a, b = map(int, input().split())
  if a == 1:
  	first.append(b)
  elif b == N:
    second.append(a)

ans = 0
for i in first:
  if i in second:
    ans = 1
    break
if ans:
  print("POSSIBLE")
else:
  print("IMPOSSIBLE")

Fixed submission:
N, M = map(int, input().split())
first = set()
second = set()
for _ in range(M):
  a, b = map(int, input().split())
  if a == 1:
    first.add(b)
  elif b == N:
    second.add(a)

ans = 0
for i in first:
  if i in second:
    ans = 1
    break
if ans:
  print("POSSIBLE")
else:
  print("IMPOSSIBLE")
Buggy python submission (verdict: Runtime Error):
S = list(str(input()))

ans = 0
num = 0
while num < len(S):
  num += 1
  s = S[:len(S)-num]
  if len(s) % 2 == 0:
  　　if s[:len(s)/2] == s[len(s)/2:]:
        ans = len(s)
        break
print(ans)

Fixed submission:
S = list(str(input()))

ans = 0
num = 0
while num < len(S):
  num += 1
  s = S[:len(S)-num]
  if len(s) % 2 == 0:
    if s[:int(len(s)/2)] == s[int(len(s)/2):]:
      ans = len(s)
      break
print(ans)
Buggy python submission (verdict: Runtime Error):
N, M = int(int, input().split())

def kaizyo(n):
  if n == 1:
    return n
  return n * (n-1) 

if N == M:
  print(2 * kaizyo(N) * kaizyo(M))
else:
  if abs(N-M) == 1:
    print(kaizyo(N) * kaizyo(M))
  else:
    print(0)

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

if N == M:
  print((2 * math.factorial(N) * math.factorial(M))%((10**9)+7))
else:
  if abs(N-M) == 1:
    print((math.factorial(N) * math.factorial(M))%((10**9)+7))
  else:
    print(0)
Buggy python submission (verdict: Runtime Error):
N = int(input())
A = map(int,input().split())

l = [0 for i in range(9)]
for a in A:
  ind = 0
  while ind < 9:
    if a < (ind+1)*400:
      break
    ind += 1
  l[ind] += 1

ans_max = 0
ans_min = 0
for i in range(0, 8):
  if l[i] > 0:
    ans_max += 1
    ans_min += 1
if l[-1] > 0:
  ans_max = min(ans_max + l[-1] , 9)
  ans_min = max(ans_min, 1)
print(ans_min, ans_max)

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

l = [0 for i in range(9)]
for a in A:
  ind = 0
  while ind < 8:
    if a < (ind+1)*400:
      break
    ind += 1
  l[ind] += 1

ans_max = 0
ans_min = 0
for i in range(0, 8):
  if l[i] > 0:
    ans_max += 1
    ans_min += 1
if l[-1] > 0:
  ans_max = ans_max + l[-1]
  ans_min = max(ans_min, 1)
print(ans_min, ans_max)
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
S = []
for i in range(N):
    S.append(int(input()))


def solve(ind, choice):
    # ending
    if ind == N:
        num = sum(choice)
        if num % 10 == 0:
            return 0
        else:
            return sum(choice)
    # transition
    return max(solve(ind=ind + 1, choice=choice + [S[ind]]), solve(ind=ind + 1, choice=choice))

print(solve(ind=0, choice=[]))

Fixed submission:
N = int(input())
S = []
for i in range(N):
    S.append(int(input()))

memo = {}


def solve(ind, points):
    # ending
    if ind == N:
        if points % 10 == 0:
            return 0
        else:
            return points

    if memo.get((ind, points)) is not None:
        return memo[(ind, points)]

    # transition
    ret = max(solve(ind=ind + 1, points=points + S[ind]), solve(ind=ind + 1, points=points))
    memo[(ind, points)] = ret

    return ret

print(solve(ind=0, points=0))
Buggy python submission (verdict: Runtime Error):
a, b, c = map(int, input().split())
if a[-1]==b[0] and b[-1]==c[0]:
  print("YES")
else:
  print("NO")

Fixed submission:
a, b, c = map(str, input().split())
if a[-1]==b[0] and b[-1]==c[0]:
  print("YES")
else:
  print("NO")
Buggy python submission (verdict: Runtime Error):
a, b = map(int, input().split())
if a>b:
  print("GREATER")
elif a<b:
  print("LESS")
else:
  print("EQUAL")

Fixed submission:
a = int(input())
b = int(input())
if a>b:
  print("GREATER")
elif a<b:
  print("LESS")
else:
  print("EQUAL")
Buggy python submission (verdict: Runtime Error):
N, M = map(int, input().split())
stu = []
for _ in range(N):
  stu.append(tuple(map(int, input().split())))
che = []
for _ in range(M):
  che.append(tuple(map(int, input().split())))

for i in range(N):
  ans = 0
  min_l = pow(10, 10)
  for j in range(M):
    l = abs(stu[i][0] - che[i][0]) + abs(stu[i][1] - che[i][1])
    if l < min_l:
      min_l = l
      ans = j+1
  print(ans)

Fixed submission:
N, M = map(int, input().split())
stu = []
for _ in range(N):
  stu.append(tuple(map(int, input().split())))
che = []
for _ in range(M):
  che.append(tuple(map(int, input().split())))

for i in range(N):
  ans = 0
  min_l = pow(10, 10)
  for j in range(M):
    l = abs(stu[i][0] - che[j][0]) + abs(stu[i][1] - che[j][1])
    if l < min_l:
      min_l = l
      ans = j+1
  print(ans)
Buggy python submission (verdict: Runtime Error):
a, b = map(int, input().split())
if a == "H":
  print(b)
else:
  if b == "H":
    print("D")
  else:
    print("H")

Fixed submission:
a, b = map(str, input().split())
if a == "H":
  print(b)
else:
  if b == "H":
    print("D")
  else:
    print("H")
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
power = 1
for i in range(N):
  power *= i+1
print(power % (10**9 + 7))

Fixed submission:
N = int(input())
power = 1
for i in range(N):
  power = (power*(i+1)) % (10**9+7)
print(power)

Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
power = 1
for i in range(N):
  power *= i+1
print(power % (pow(10, 9) + 7))

Fixed submission:
N = int(input())
power = 1
for i in range(N):
  power = (power*(i+1)) % (10**9+7)
print(power)

Buggy python submission (verdict: Runtime Error):
N = int(input())
power = 1
for i in range(N):
  power *= i+1
print(power / (pow(10, 9) + 7))

Fixed submission:
N = int(input())
power = 1
for i in range(N):
  power = (power*(i+1)) % (10**9+7)
print(power)
Buggy python submission (verdict: Runtime Error):
a,b,c = map(int,input().split())
l = [a,b,c]
l.sort()
if l[0] + 1[1] == 1[2]:
  print("Yes")
else:
  print("No")

Fixed submission:
a,b,c = map(int,input().split())
l = [a,b,c]
l.sort()
if l[0] + l[1] == l[2]:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
w = str(input())
s = dic()

for wrd in w:
  if s.get(wrd) is None:
    s[wrd] = 1
  else:
    s[wrd] += 1

ans = 1
for wrd in s:
  if s[wrd] %2 !=0:
    ans = 0
    break
if ans:
  print("Yes")
else:
  print("No")




Fixed submission:
w = str(input())
s = {}
 
for wrd in w:
  if s.get(wrd) is None:
    s[wrd] = 1
  else:
    s[wrd] += 1
 
ans = 1
for wrd in s:
  if s[wrd] %2 !=0:
    ans = 0
    break
if ans:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Time Limit Exceeded):
import sys

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

dp = [0] * (H + 1)

for x in range(1, H + 1):
    dp[x] = min(dp[max(x - damage, 0)] + cost for damage, cost in magic)

print(dp[H])

Fixed submission:
H, N = map(int, input().split())
magic = [list(map(int, input().split())) for _ in range(N)]

max_damage = max(damage for damage, cost in magic)
dp = [0] * (H + max_damage)

for x in range(1, H + max_damage):
    dp[x] = min(dp[x - damage] + cost for damage, cost in magic)

print(min(dp[H:]))
Buggy python submission (verdict: Runtime Error):
N = int(input())
P = list(map(int, input().split()))

cnt = 0
for i in range(N):
    Flg = True
    for j in range(i):
        if P[j] < P[i]:
            Flg = False
            break
    if Flg:
        cnt += 1
print(cnt)

Fixed submission:
N, M = map(int, input().split())
if N == M:
    print("Yes")
else:
    print("No")
Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
P = list(map(int, input().split()))

cnt = 0
for i in range(N):
    Flg = True
    for j in range(i+1):
        if P[j] < P[i]:
            Flg = False
            break
    if Flg:
        cnt += 1
print(cnt)


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

cnt = 0
min_value = N + 1
for i in range(N):
    if P[i] <= min_value:
        cnt += 1
        min_value = P[i]
print(cnt)

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

cnt = 0
print(len([i for i in range(N) if all([False if P[i] > P[j] else True for j in range(i)])]))


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

cnt = 0
min_value = N + 1
for i in range(N):
    if P[i] <= min_value:
        cnt += 1
        min_value = P[i]
print(cnt)

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

cnt = 0
print(len([i for i in range(N) if all([True if P[j] >= P[i] else False for j in range(i)])]))


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

cnt = 0
min_value = N + 1
for i in range(N):
    if P[i] <= min_value:
        cnt += 1
        min_value = P[i]
print(cnt)

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

cnt = 0
for i in range(N):
    Flg = True
    for j in range(i):
        if P[j] < P[i]:
            Flg = False
            break
    if Flg:
        cnt += 1
print(cnt)

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

cnt = 0
min_value = N + 1
for i in range(N):
    if P[i] <= min_value:
        cnt += 1
        min_value = P[i]
print(cnt)

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

cnt = 0
for i in range(N):
    if all([True if P[j] >= P[i] else False for j in range(i+1)]):
        cnt += 1
print(cnt)


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

cnt = 0
min_value = N + 1
for i in range(N):
    if P[i] <= min_value:
        cnt += 1
        min_value = P[i]
print(cnt)
Buggy python submission (verdict: Runtime Error):
H = int(input())

def calc(H):
  a = int(H/2)
  return a*2 + 1


def main(H):
  if H == 1:
    return 1
  else:
    return calc(H)

if __name__=='__main__':
  main()


Fixed submission:
H = int(input())
 
 
def main(H):
  if H == 1:
    return 1
  else:
    return main(H//2)*2 + 1
 
if __name__=='__main__':
  print(main(H))
Buggy python submission (verdict: Runtime Error):
N,M = int(input()).split()

if N == M:
  print("Yes")
else:
  print("No")
    

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

if N == M:
  print("Yes")
else:
  print("No")
Buggy python submission (verdict: Runtime Error):
A, B, K = map(int, input().split())


if A + B <= K:
    print(0, 0)

elif A <= K:
    C = K - A
    print(0, B-C)

else:
    print(A - K, B)


Fixed submission:
S, T = input().split()
print(T+S)

Buggy python submission (verdict: Runtime Error):
A, B, K = map(int, input().split())


if A + B <= K:
    print(0, 0)

elif A <= K:
    C = K - A
    print(0, B-C)

else:
    print(A - K, B)


Fixed submission:
S, T = input().split()
print(T+S)
Buggy python submission (verdict: Runtime Error):
A,B = map(int,input())

print(6 - A - B)


Fixed submission:
A = int(input())
B = int(input())

print(6-A-B)
Buggy python submission (verdict: Runtime Error):
N = int(input())
A,B = input().split()
ans = []
for i in range(N+1):
  ans.append(A[i] + B[i])
print("".join(ans))

Fixed submission:
N = int(input())
A,B = input().split()
ans = []
for i in range(0,N):
  ans.append(A[i] + B[i])

print("".join(ans))
Buggy python submission (verdict: Runtime Error):
import math

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

def lcm(A, B):
    return (A * B) // math.gcd(A, B)

print(lcm(a, b))

Fixed submission:
from fractions import gcd 

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

def lcm(A, B):
    return (A * B) // gcd(A, B)

print(lcm(A, B))
Buggy python submission (verdict: Runtime Error):
r = input()

print(r*r)

Fixed submission:
r = int(input())


print(r*r)

Buggy python submission (verdict: Runtime Error):
def main(r):
  return r*r
  
  

if __name__ == '__main__':
  r = input()
  main()

Fixed submission:
r = int(input())


print(r*r)

Buggy python submission (verdict: Runtime Error):

def main(r):
  return r*r
  

if __name__ == '__main__':
  r = int(input())
  main()

Fixed submission:
r = int(input())


print(r*r)