Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
try:
    s1=(input(''))
    if len(s1)>=4:
        raise ValueError
    
    check=list((s1))
    assert bool(int(check[0]+check[1])<=12) != bool(int(check[2]+check[3])<=12)
    if int(check[0]+check[1])<=12:
        print("MMYY")
    elif int(check[2]+check[3])<=12:
        print("YYMM")
except AssertionError:
    if int(check[0]+check[1])<=12 and int(check[2]+check[3])<=12:
        print("AMBIGUOUS")
    else:
        print("NA")



Fixed submission:
a=input()
 
b = int(a[:2])
c = int(a[2:])
 
if 0< b < 13:
    a_month_flag = 1
    
elif b == 0:
    a_month_flag = 0    
else:
    a_month_flag = 0
 
if 0< c < 13:
    b_month_flag = 1
    
elif c == 0:
    b_month_flag = 0
  
else:
    b_month_flag = 0
 
if a_month_flag ==1 and b_month_flag==1:
    print("AMBIGUOUS")
elif a_month_flag == 1 and b_month_flag == 0:
    print("MMYY")
elif a_month_flag == 0 and b_month_flag ==1:
    print("YYMM")
else:
    print("NA")
Buggy python submission (verdict: Time Limit Exceeded):
i = 1
N = int(input())
while True:
  if i % 2 == 0 and i % N == 0:
    print(i)
    break
  i = i + 1

Fixed submission:
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(N*2)

Buggy python submission (verdict: Time Limit Exceeded):
N = int(input())
for i in range(1,10000000000):
  if i % 2 == 0 and i % N == 0:
    print(i)
    break

Fixed submission:
N = int(input())
if N % 2 == 0:
  print(N)
else:
  print(N*2)
Buggy python submission (verdict: Runtime Error):
Alice = 0
Bob = 0
N = int(input())
a = list(map(int, input().split()))
a.sort(reverse = True)
Alice = a[::2]
Bob = a[1::2]
print(Alice-Bob)

Fixed submission:
Alice = 0
Bob = 0
N = int(input())
a = list(map(int, input().split()))
a.sort(reverse = True)
Alice = a[::2]
Bob = a[1::2]
print(sum(Alice)-sum(Bob))
Buggy python submission (verdict: Runtime Error):
a,b = int(input())
if a*b % 2 == 1:
  print("Odd")
else:
  print("Even")

Fixed submission:
a, b = map(int, input().split())
if a*b % 2 == 1:
  print("Odd")
else:
  print("Even")
Buggy python submission (verdict: Runtime Error):
import numpy as np
N=int(input())
a=[]
b=[]
xa=[]
xb=[]
y=[]
for i in range (0,N):
    c,d=(int(x) for x in input().split(" "))
    xa.append(c)
    xb.append(d)
     
z=np.argsort(xb)

for i in range (0,N):
    a.append(xa[z[i]])
    b.append(xb[z[i]])
for i in range (0,N):
    if i==0:
      	y.append(a[0])
    else:
      	y.append(a[i]+y[i-1])
def check(i,a,b):
    if b[i]>=y[i]:
        return True
    else:
        return False
def final_check(a,b,N):
    for i in range (0,N):
        if check(i,a,b)==False:
            return "No"
    return "Yes"
print (final_check(a,b,N))


Fixed submission:
x=input()
def goodorbad(n):
    for i in range (0,3):
        if n[i]==n[i+1]:
            return "Bad\n"
    return "Good\n"
print (goodorbad(x))
Buggy python submission (verdict: Runtime Error):
import math
A,B,C,D=(int(x) for x in input().split(" "))
def gcd(x,y): 
  
   while(y): 
        x, y = y, x % y 
  
   return x 
def nb_divisers(n,m):
    return n//m
def nb_d_btw(f,g,n):
    if f%n==0:
        return nb_divisers(g,n)-nb_divisers(f,n)+1
    else:
        return nb_divisers(g,n)-nb_divisers(f,n)
def nb_notdivisers_f(a,b,c,d):
    e=int(c*d/math.gcd(c,d))
    return b-a+1-(nb_d_btw(a,b,c)+nb_d_btw(a,b,d)-nb_d_btw(a,b,e))
print(nb_notdivisers_f(A,B,C,D))

Fixed submission:
A, B, C, D=(int(x) for x in input().split(" "))
import fractions

def eks(x,a):
    return a//x

def wai(x):
    return eks(x,B)-eks(x,A-1)

def lcm(a,b):
    return a*b//fractions.gcd(a,b)

zet=B-A+1-(wai(C)+wai(D)-wai(lcm(C,D)))
print (zet)

Buggy python submission (verdict: Runtime Error):
import math
A,B,C,D=(int(x) for x in input().split(" "))
def nb_divisers(n,m):
    return n//m
def nb_d_btw(f,g,n):
    if f%n==0:
        print(nb_divisers(g,n)-nb_divisers(f,n)+1)
        return nb_divisers(g,n)-nb_divisers(f,n)+1
    else:
        print(nb_divisers(g,n)-nb_divisers(f,n))
        return nb_divisers(g,n)-nb_divisers(f,n)
def nb_notdivisers_f(a,b,c,d):
    e=int(c*d/math.gcd(c,d))
    return b-a+1-(nb_d_btw(a,b,c)+nb_d_btw(a,b,d)-nb_d_btw(a,b,e))
print(nb_notdivisers_f(A,B,C,D))

Fixed submission:
A, B, C, D=(int(x) for x in input().split(" "))
import fractions

def eks(x,a):
    return a//x

def wai(x):
    return eks(x,B)-eks(x,A-1)

def lcm(a,b):
    return a*b//fractions.gcd(a,b)

zet=B-A+1-(wai(C)+wai(D)-wai(lcm(C,D)))
print (zet)

Buggy python submission (verdict: Runtime Error):
import math
a,b,c,d=input().split(" ")
A=int(a)
B=int(b)
C=int(c)
D=int(d)
def nb_divisers(n,m):
    return n//m
def nb_d_btw(f,g,n):
    if f%n==0:
        print(nb_divisers(g,n)-nb_divisers(f,n)+1)
        return nb_divisers(g,n)-nb_divisers(f,n)+1
    else:
        print(nb_divisers(g,n)-nb_divisers(f,n))
        return nb_divisers(g,n)-nb_divisers(f,n)
def nb_notdivisers_f(a,b,c,d):
    e=int(c*d/math.gcd(c,d))
    return b-a+1-(nb_d_btw(a,b,c)+nb_d_btw(a,b,d)-nb_d_btw(a,b,e))
print(nb_notdivisers_f(A,B,C,D))

Fixed submission:
A, B, C, D=(int(x) for x in input().split(" "))
import fractions

def eks(x,a):
    return a//x

def wai(x):
    return eks(x,B)-eks(x,A-1)

def lcm(a,b):
    return a*b//fractions.gcd(a,b)

zet=B-A+1-(wai(C)+wai(D)-wai(lcm(C,D)))
print (zet)
Buggy python submission (verdict: Time Limit Exceeded):
import numpy as np
N=int(input())
a=[]
b=[]
xa=[]
xb=[]
for i in range (0,N):
    c,d=(int(x) for x in input().split(" "))
    xa.append(c)
    xb.append(d)
     
z=np.argsort(xb)

for i in range (0,N):
    a.append(xa[z[i]])
    b.append(xb[z[i]])

def sum_a(i):
    e=0
    for k in range (0,i+1):
        e+=a[k]
    return e
def check(i,a,b):
    if b[i]>=sum_a(i):
        return True
    else:
        return False
def final_check(a,b,N):
    for i in range (0,N):
        if check(i,a,b)==False:
            return "No"
    return "Yes"
print (final_check(a,b,N))




Fixed submission:
import numpy as np
N=int(input())
a=[]
b=[]
xa=[]
xb=[]
y=[]
for i in range (0,N):
    c,d=(int(x) for x in input().split(" "))
    xa.append(c)
    xb.append(d)
     
z=np.argsort(xb)

for i in range (0,N):
    a.append(xa[z[i]])
    b.append(xb[z[i]])
for i in range (0,N):
    if i==0:
      	y.append(a[0])
    else:
      	y.append(a[i]+y[i-1])
def check(i,a,b):
    if b[i]>=y[i]:
        return True
    else:
        return False
def final_check(a,b,N):
    for i in range (0,N):
        if check(i,a,b)==False:
            return "No"
    return "Yes"
print (final_check(a,b,N))
Buggy python submission (verdict: Time Limit Exceeded):
n, m = map(int, input().split())
card = []
cntAppearance = []
for i in range(n):
        cntAppearance.append(0)
for _ in range(m):
        l ,r = map(int, input().split())
        for i in range(l,r+1):
                card.append(i)
for j in card:
        cntAppearance[j-1] += 1
cnt = 0
for i in cntAppearance:
        if i == m:
                cnt += 1
print(cnt)

Fixed submission:
n, m = map(int, input().split())
cnt = 0
id = []
for _ in range(m):
        l= list(map(int, input().split()))
        if len(id) == 0:
                id = l
        else:
                if id[0] < l[0]:
                        id[0] = l[0]
                elif id[1] > l[1]:
                        id[1] = l[1]
if id[1] < id[0]:
        cnt = 0
else:
        cnt = id[1]-id[0]+1
print(cnt)
Buggy python submission (verdict: Runtime Error):
import math

list = []
for i in range(5):
    list.append(int(input()))
sum = 0
zeroList = [list[i] for i in range(len(list)) if list[i]%10 == 0]
otherList = [list[i] for i in range(len(list)) if not list[i]%10 == 0]
def func(x):
    return x % 10
otherList.sort(key=func)
for i in range(len(zeroList)):
    sum += zeroList[i]
for i in (otherList[1:]):
    sum += math.ceil(i/10)*10
sum += otherList[0]
print(sum)


Fixed submission:
import math

list = []
for i in range(5):
    list.append(int(input()))
sum = 0
zeroList = [list[i] for i in range(len(list)) if list[i]%10 == 0]
otherList = [list[i] for i in range(len(list)) if not list[i]%10 == 0]
def func(x):
    return x % 10
otherList.sort(key=func)
for i in range(len(zeroList)):
    sum += zeroList[i]
for i in (otherList[1:]):
    sum += math.ceil(i/10)*10
if not len(otherList) == 0:
    sum += otherList[0]
print(sum)

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

list = []
for i in range(5):
    a = int(input())
    list.append(a)
sum = 0
zeroList = [list[i] for i in range(len(list)) if list[i]%10 == 0]
otherList = [list[i] for i in range(len(list)) if not list[i]%10 == 0]
def func(x):
    return x % 10
otherList.sort(key=func)
print(otherList)
for i in range(len(zeroList)):
    sum += zeroList[i]
    print(sum)
for i in (otherList[1:]):
    sum += math.ceil(i/10)*10
sum += otherList[0]
print(sum)


Fixed submission:
import math

list = []
for i in range(5):
    list.append(int(input()))
sum = 0
zeroList = [list[i] for i in range(len(list)) if list[i]%10 == 0]
otherList = [list[i] for i in range(len(list)) if not list[i]%10 == 0]
def func(x):
    return x % 10
otherList.sort(key=func)
for i in range(len(zeroList)):
    sum += zeroList[i]
for i in (otherList[1:]):
    sum += math.ceil(i/10)*10
if not len(otherList) == 0:
    sum += otherList[0]
print(sum)
Buggy python submission (verdict: Runtime Error):
s = list(input())
cnt = 0
list = []
for i in range(len(s)):
    if s[i] in ['A','C','G','T']:
        cnt += 1
    else:
        if cnt > 0:
            list.append(cnt)
            cnt = 0
if not cnt == 0:
    list.append(cnt)
max = max(list)
print(max)


Fixed submission:
s = list(input())
cnt = 0
list = []
for i in range(len(s)):
    if s[i] in ['A','C','G','T']:
        cnt += 1
    else:
        if cnt > 0:
            list.append(cnt)
            cnt = 0
if not cnt == 0:
    list.append(cnt)
if len(list) == 0:
    list.append(0)
max = max(list)
print(max)

Buggy python submission (verdict: Runtime Error):
s = list(input())
cnt = 0
list = []
for i in range(len(s)):
    if s[i] in ['A','C','G','T']:
        cnt += 1
    else:
        list.append(cnt)
        cnt = 0
max = max(list)
print(max)


Fixed submission:
s = list(input())
cnt = 0
list = []
for i in range(len(s)):
    if s[i] in ['A','C','G','T']:
        cnt += 1
    else:
        if cnt > 0:
            list.append(cnt)
            cnt = 0
if not cnt == 0:
    list.append(cnt)
if len(list) == 0:
    list.append(0)
max = max(list)
print(max)
Buggy python submission (verdict: Runtime Error):
# review
import copy
n, a, b, c = map(int, input().split())
lList = []

for _ in range(n) :
        lList.append(int(input()))

lList.sort()
goal = [a, b, c]
goal.sort()

def removed(i,j) :
        goal.remove(i)
        lList.remove(j)

mp = 0
def pick(x, y) : # if same value & goal < lList
        mp = 0
        for i in copy.copy(x) :
                for j in copy.copy(y) :
                        if i == j and i in goal:
                                removed(i,j)
        for i in copy.copy(x) :
                for j in copy.copy(y) :
                        if i < j and i in goal:
                                mp += j - i 
                                removed(i,j)

pick(goal,lList)      


diffList = []
diff = 10
for j in lList :
        for i in goal :
                if abs(i-j) < 10 :
                        diff = min(diff, abs(i-j))
        if diff != 10 :
                diffList.append([diff, i, j])
        diff = 10
for i in diffList :      
        mp += i[0]       
        goal.remove(i[1])
        lList.remove(i[2])

add2 = []
for i in lList :
        for j in lList[i+1:] :
                add2.append(i + j, i, j)
# ------------------------------------------------------
# addList = []
# diff = 10
# for j in add2 :
#         for i in goal :
#                 if abs(i-j[0]) < 10 :
#                         diff = min(diff, abs(i-j[0]))
#         if diff != 10 :
#                 diffList.append([diff, i, j[0]])
#         diff = 10
# for i in diffList :      
#         mp += i[0]       
#         goal.remove(i[1])
#         lList.remove(i[2])


             
print(mp)


Fixed submission:
# review
N,A,B,C = map(int,input().split())
L = [int(input()) for _ in range(N)]
 
def f(i,a,b,c):
    if i == N:
        if min(a, b, c) <= 0:
            return 10**9
        return abs(a-A)+abs(b-B)+abs(c-C)-30
    costx = f(i+1,a,b,c)
    costA = f(i+1,a+L[i],b,c)+10
    costB = f(i+1,a,b+L[i],c)+10
    costC = f(i+1,a,b,c+L[i])+10
    return min(costx,costA,costB,costC)
 
print(f(0,0,0,0))
Buggy python submission (verdict: Runtime Error):
n = int(input())
ans = 0
for i in range(1,n+1,2) :
	cnt = 0
	for j in range(1,i+1) :
		if i % j == 0 :
        	cnt += 1
	if cnt == 8 :
		ans += 1
print(ans)     


Fixed submission:
n = int(input())
cnt = 0
divisor = []
for i in range(1,n+1,2) :
        for j in range(1,i+1) :
                if i % j == 0 :
                        cnt += 1
        divisor.append(cnt)
        cnt = 0
ans = 0
for i in divisor :
        if i == 8 :
                ans += 1
print(ans)

Buggy python submission (verdict: Runtime Error):
n = int(input())
ans = 0
for i in range(1,n+1,2) :
 	cnt = 0
	for j in range(1,i+1) :
		if i % j == 0 :
        	cnt += 1
	if cnt == 8 :
		ans += 1
print(ans)     

Fixed submission:
n = int(input())
cnt = 0
divisor = []
for i in range(1,n+1,2) :
        for j in range(1,i+1) :
                if i % j == 0 :
                        cnt += 1
        divisor.append(cnt)
        cnt = 0
ans = 0
for i in divisor :
        if i == 8 :
                ans += 1
print(ans)

Buggy python submission (verdict: Runtime Error):
n = int(input())
ans = 0
for i in range(1,n+1,2) :
  cnt = 0
    for j in range(1,i+1) :
      if i % j == 0 :
        cnt += 1
    if cnt == 8 :
      ans += 1
print(ans)     

Fixed submission:
n = int(input())
cnt = 0
divisor = []
for i in range(1,n+1,2) :
        for j in range(1,i+1) :
                if i % j == 0 :
                        cnt += 1
        divisor.append(cnt)
        cnt = 0
ans = 0
for i in divisor :
        if i == 8 :
                ans += 1
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
a, b, k = map(int, input().split())
for i in range(a, min(a + k, b)) :
        if a <= i < a + k :
                print(i)
for i in range(min(a + k, b), b + 1) :
        if b - k < i :
                print(i)

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

Buggy python submission (verdict: Time Limit Exceeded):
a, b, k = map(int, input().split())
for i in range(a, b+1) :
        if a <= i < a + k or b - k < i :
                print(i)

Fixed submission:
a, b, k = map(int, input().split())
if k > (b - a)//2 :
	for i in range(a, b+1) :
		print(i)   
	exit()
for i in range(a, a + k) :          
	if a <= i < a + k :
		print(i)
for i in range(b - k, b + 1) :
	if b - k < i and a + k <= i:
		print(i)
Buggy python submission (verdict: Runtime Error):
n = int(input())
l = []
ans = 1
for _ in range(n) :
	l.append(int(input()))
if l[0] == 2 :
	print(1)
else :
    i = l[0] - 1
	while True :
		if l[i] == 2 :
			ans += 1
			break
		i = l[i] - 1
		ans += 1
		if ans == n+1 :
			print(-1)
			exit()
	print(ans)

Fixed submission:
n = int(input())
l = []
ans = 1
for _ in range(n) :
	l.append(int(input()))
if l[0] == 2 :
	print(1)
else :
    i = l[0] - 1
    while True :
        if l[i] == 2 :
            ans += 1
            break
        i = l[i] - 1
        ans += 1
        if ans == n+1 :
            print(-1)
            exit()
    print(ans)

Buggy python submission (verdict: Runtime Error):
n = int(input())
l = []
ans = 1
for _ in range(n) :
	l.append(int(input()))
if l[0] == 2 :
	print(1)
else :
	i = l[0] - 1
while True :
	if l[i] == 2 :
		ans += 1
		break
	i = l[i] - 1
	ans += 1
	if ans == n+1 :
		print('-1')
		exit()
print(ans)

Fixed submission:
n = int(input())
l = []
ans = 1
for _ in range(n) :
	l.append(int(input()))
if l[0] == 2 :
	print(1)
else :
    i = l[0] - 1
    while True :
        if l[i] == 2 :
            ans += 1
            break
        i = l[i] - 1
        ans += 1
        if ans == n+1 :
            print(-1)
            exit()
    print(ans)
Buggy python submission (verdict: Runtime Error):
a, b = map(int, input().split())
if a == b :
	print('H')
else : 
	print('D')

Fixed submission:
a, b = map(str, input().split())
if a == b :
	print('H')
else : 
	print('D')
Buggy python submission (verdict: Runtime Error):
n = int(input())
print((800 * n) - (200 * (n//15))

Fixed submission:
n = int(input())
print((800 * n) - (200 * (n//15)))
Buggy python submission (verdict: Time Limit Exceeded):
k, s = map(int, input().split())
cnt = 0
for x in range(k+1):
    for y in range(k+1):
        for z in range(k+1):
            if x + y + z == s:
                cnt += 1
print(cnt)

Fixed submission:
#review

def solve(k, s):
    ans = 0
    for x in range(k+1):
        for y in range(k+1):
            z = s - x - y
            if 0 <= z <= k:
                ans += 1
            elif z < 0:
                break
    return ans
 
 
def main():
    k, s = map(int, input().split())
    ans = solve(k, s)
    print(ans)
 
 
if __name__ == '__main__':
    main()

Buggy python submission (verdict: Time Limit Exceeded):
k, s = map(int, input().split())
cnt = 0
for x in range(s+1):
    for y in range(s+1):
        for z in range(s+1):
            if 0 <= x <= k and 0 <= y <= k and 0 <= z <= k and x + y + z == s:
                cnt += 1
print(cnt)

Fixed submission:
#review

def solve(k, s):
    ans = 0
    for x in range(k+1):
        for y in range(k+1):
            z = s - x - y
            if 0 <= z <= k:
                ans += 1
            elif z < 0:
                break
    return ans
 
 
def main():
    k, s = map(int, input().split())
    ans = solve(k, s)
    print(ans)
 
 
if __name__ == '__main__':
    main()
Buggy python submission (verdict: Runtime Error):
def bonus(i, l):
  if i in l:
    return 0
  else:
    return (len(l)+1)*(len(l)+1) - len(l)*len(l)

l = raw_input().split()
n = []
variety =[]
count = 0
for x in range(int(l[0])):
  n.append(map(lambda x: int(x),raw_input().split()))

for y in range(int(l[1])):
  max_saf = 0
  num = 0
  for i, x in enumerate(n):
    if max_saf < x[1] + bonus(x[0], variety):
      max_saf = x[1] + bonus(x[0], variety)
      num = i
    
  count = count + max_saf
  print(n[num])
  print(variety)
  print(max_saf)
  if not n[num][0] in variety:
  	variety.append(n[num][0])
  del n[num]
    
    
print (count)

Fixed submission:
l = raw_input().split()

l = map(lambda x: int(x), l)
l.sort()

print l[0] * l[1] / 2
Buggy python submission (verdict: Runtime Error):
N = input()
a = []
f = True
for i in range(N):
  a.append(input())
    
for x in range(N-1):
  if a[x][:1] != a[x+1][-1:]:
    f = False
    
if len(a) != len(set(a)):
  f = False

if f:
  print "Yes"
else:
  print "No"

Fixed submission:
N = input()
a = []
f = True
for i in range(N):
  a.append(raw_input())
    
for x in range(N-1):
  if a[x][-1:] != a[x+1][:1]:
    f = False
    
if len(a) != len(set(a)):
  f = False

if f:
  print "Yes"
else:
  print "No"
Buggy python submission (verdict: Runtime Error):
import fractions

A, B, C, D = tuple([int(a) for a in input().split(' ')])


def func1(n):
    return n - n//C - n//D + n//(C*D//fractions.gcd(C, D))


print(func1(B) - func1(A-1))


Fixed submission:
_input = input()
S = _input

tmp = None
ans = 'Good'
for s in S:
    if s == tmp:
        ans = 'Bad'
        break
    tmp = s

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

# 01:10
A, B, C, D = tuple([int(a) for a in input().split(' ')])


def func1(n):
    return n - n//C - n//D + n//(C*D//math.gcd(C, D))


print(func1(B) - func1(A-1))


Fixed submission:
import fractions 

# 01:10
A, B, C, D = tuple([int(a) for a in input().split(' ')])


def func1(n):
    return n - n//C - n//D + n//(C*D//fractions.gcd(C, D))


print(func1(B) - func1(A-1))
Buggy python submission (verdict: Runtime Error):
n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  mini = min(list(map(abs, ajis)))
  mini = mini * -1
  if mini in ajis:
    pass
  else:
    mini = mini * -1
  print(ajis)
  ajis.remove(mini)
  print(ajis)
  return sum(ajis)

print(apple_pie(range(1, int(n))))

Fixed submission:
param = input()
s = list(map(int, list(str(param))))

pre = None
check = True
 
for i in s:
  if pre != None:
    if pre == i:
      print("Bad")
      check = False
      break
  pre = i
  
if check:
  print("Good")
Buggy python submission (verdict: Runtime Error):
n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  mini = min(list(map(abs, ajis)))
  ajis.remove(mini)
  return sum(ajis)

print(apple_pie(range(1, int(n))))

Fixed submission:
n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def remove_min(p):
  minimun = min(list(map(abs, p)))
  if minimun not in p:
    minimun = minimun * -1
  p.remove(minimun)
  return p

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  return sum(remove_min(ajis))

print(apple_pie(range(1, int(n)+1)))

Buggy python submission (verdict: Runtime Error):
n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  ajis.sort()
  mini = min([abs(x) for x in ajis])
  ajis.remove(mini)
  return sum(ajis)

print(apple_pie(range(1, int(n))))


Fixed submission:
n, l = input().split()

def apple_aji(i):
  return int(l) + int(i) - 1

def remove_min(p):
  minimun = min(list(map(abs, p)))
  if minimun not in p:
    minimun = minimun * -1
  p.remove(minimun)
  return p

def apple_pie(n):
  ajis = [apple_aji(x) for x in n]
  return sum(remove_min(ajis))

print(apple_pie(range(1, int(n)+1)))
Buggy python submission (verdict: Runtime Error):
#ABC131c

import math
from functools import reduce

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


count_c=b//c - (a-1)//c
count_d=b//d - (a-1)//d
count_cd=b//(c*d//math.gcd(c,d)) - (a-1)//(c*d//math.gcd(c,d))

print(b-a+1-count_c-count_d+count_cd)



Fixed submission:
#ABC131c 3.4以前ではmathではなくfractons

import fractions

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


count_c=b//c - (a-1)//c
count_d=b//d - (a-1)//d
count_cd=b//(c*d//fractions.gcd(c,d)) - (a-1)//(c*d//fractions.gcd(c,d))

print(b-a+1-count_c-count_d+count_cd)

Buggy python submission (verdict: Runtime Error):
#ABC131c

import math


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


count_c=b//c - (a-1)//c
count_d=b//d - (a-1)//d
count_cd=b//(c*d//math.gcd(c,d)) - (a-1)//(c*d//math.gcd(c,d))

print(b-a+1-count_c-count_d+count_cd)



Fixed submission:
#ABC131c 3.4以前ではmathではなくfractons

import fractions

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


count_c=b//c - (a-1)//c
count_d=b//d - (a-1)//d
count_cd=b//(c*d//fractions.gcd(c,d)) - (a-1)//(c*d//fractions.gcd(c,d))

print(b-a+1-count_c-count_d+count_cd)
Buggy python submission (verdict: Runtime Error):
#https://atcoder.jp/contests/abc125/tasks/abc125_d

from functools import reduce

def positivesum(lists):
	for i in range(len(lists)):
		if lists[i]<0:
			lists[i]=lists[i]*(-1)
	return(sum(lists))
	

n=int(input())
alist=list(map(int,input().split()))

#負数の数をカウント
count=0
for i in range(n):
	if alist[i]<0:
		count+=1

if count%2==0:
	print(positivesum(alist))
else:
	alist.sort()
	x=max(alist[count-1],-alist[count])
	print(positivesum(alist)+x*2)



Fixed submission:
#https://atcoder.jp/contests/abc125/tasks/abc125_d

from functools import reduce

def positivesum(lists):
	for i in range(len(lists)):
		if lists[i]<0:
			lists[i]=lists[i]*(-1)
	return(sum(lists))
	

n=int(input())
alist=list(map(int,input().split()))

#負数の数をカウント
count=0
for i in range(n):
	if alist[i]<0:
		count+=1


if count==n and count%2==1:
	print(-sum(alist)+2*max(alist))

elif count%2==0:
	print(positivesum(alist))
else:
	alist.sort()
	x=max(alist[count-1],-alist[count])
	print(positivesum(alist)+x*2)