qyliang/CodeNanoFix huggingface dataset:
Buggy code:
N=int(input())
def f(x):
  s=0
  while x!=0:
    s+=x%10
    x//=10
  return(s)
minn=50
for i in range(1,N/2):
  minn=min(f(i)+f(N-i),minn)
print(minn)

Fixed code:
N=int(input())
def f(x):
  s=0
  while x!=0:
    s+=x%10
    x//=10
  return(s)
minn=50
for i in range(1,N):
  minn=min(f(i)+f(N-i),minn)
print(minn)
Buggy code:
# Digits Sum
import sys

N = int(input())

def getValue(wk) :
    ret = 0
    while wk > 0 :
        ret = ret + wk % 10
        wk = wk // 10
    return ret

def getAns(n) :
    minV = 999999
    B = n
    for A in range(1, n + 1) :
        B = B - 1
        if A + B == n :
            waA = getValue(A)
            waB = getValue(B)
            if minV > waA + waB :
                minV = waA + waB
    return minV

print(getAns(N))

Fixed code:
# Digits Sum
import sys
import math
N = int(input())

def getValue(wk) :
    ret = 0
    while wk > 0 :
        ret = ret + wk % 10
        wk = wk // 10
    return ret

def getAns(n) :
    minV = 999999
    B = n
    l = math.log10(n)
    if int(l) == l :
        return 10
    for A in range(1, n + 1) :
        B = B - 1
        if A + B == n :
            waA = getValue(A)
            waB = getValue(B)
            if minV > waA + waB :
                minV = waA + waB
    return minV

print(getAns(N))
Buggy code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
ans = 100
def colsum(s):
    ret = 0
    for i in s:
        ret += int(i)
    return ret

for i in range(n):
    cand = colsum(str(i))+colsum(str(n-i))
    ans = min(cand,ans)
print(ans)

Fixed code:
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))
def ism():return map(str,input().split())
def isl():return list(map(str,input().split()))

n = ii()
ans = 100
def colsum(s):
    ret = 0
    for i in s:
        ret += int(i)
    return ret

for i in range(1,n):
    cand = colsum(str(i))+colsum(str(n-i))
    ans = min(cand,ans)
print(ans)
Buggy code:
N = int(input())
A = [i for i in str(N)]
result = 0
for j in range(len(A)):
  result += A[j]
if result == 0 and A[0] == 1:
  print(10)
else:
  print(result)

Fixed code:
N = int(input())
A = [i for i in str(N)]
result = 0
for j in range(len(A)):
  result += int(A[j])
if result == 1 and A[0] == "1":
  print(10)
else:
  print(result)
Buggy code:
n=int(input())
print(min([sum([int(a) for a in str(i)])+sum([int(b) for b in str(n-i)]) for i in range(n)]))


Fixed code:
n=int(input())
print(min([sum([int(a) for a in str(i)])+sum([int(b) for b in str(n-i)]) for i in range(1,int(n))]))
Buggy code:
N = int(input())

MIN = 100000000000000
for i in range(N+1):
  A = sum(map(int,list(str(i))))
  B = sum(map(int,list(str(N-i))))
  MIN = min(A+B,MIN)
  
print(MIN)
  

Fixed code:
N = int(input())

MIN = 100000000000000
for i in range(1,N):
  A = sum(map(int,list(str(i))))
  B = sum(map(int,list(str(N-i))))
  MIN = min(A+B,MIN)
  
print(MIN)
Buggy code:
N = int(input())

def digit_sum(a, b):
    ab_sum = 0
    for i in range(1, len(str(a))+1):
        ab_sum += a % (10*i)
        a = a // (10*i)
    
    for i in range(1, len(str(b))+1):
        ab_sum += b % (10*i)
        b = b // (10*i)
    
    return ab_sum

max_sum = float("inf")
for i in range(1, N//2+1):
    a = i
    b = N - i
    if digit_sum(a, b) < max_sum:
        max_sum = digit_sum(a, b)

print(max_sum)

Fixed code:
N = int(input())

def digit_sum(a, b):
    ab_sum = 0
    for i in range(1, len(str(a))+1):
        ab_sum += a % 10
        a = a // 10
    
    for i in range(1, len(str(b))+1):
        ab_sum += b % 10
        b = b // 10
    
    return ab_sum

min_sum = float("inf")
for i in range(1, (N//2)+1):
    a = i
    b = N - i
    if digit_sum(a, b) < min_sum:
        min_sum = digit_sum(a, b)

print(min_sum)
Buggy code:
N=list(input())
ans=0
for x in N:
  x=int(x)
  if x%2==1:
    ans+=1
  ans+=(x//2)*2
print(ans)

Fixed code:
N=list(input())
ans=0
for x in N:
  x=int(x)
  if x%2==1:
    ans+=1
  ans+=(x//2)*2
if ans==1:
  print(10)
else:
  print(ans)
Buggy code:
import math
N = int(input())
n = N
amari = 0
for i in range (len(str(N))):
  amari += n % 10
  n = math.floor(n / 10)
if amari < 10:
  print(10+amari)
else:
  print(amari)

Fixed code:
import math
N = int(input())
n = N
amari = 0
for i in range (len(str(N))):
  amari += n % 10
  n = math.floor(n / 10)
if amari == 1:
  print(10)
else:
  print(amari)
Buggy code:
n=input()
ls = [10**i for i in range(1,6)]
if int(n) in ls:
  print(10)
else:
  print(sum([list(n)[i] for i in range(len(n))]))

Fixed code:
n=input()
ls = [10**i for i in range(1,6)]
if int(n) in ls:
  print(10)
else:
  print(sum([int(list(n)[i]) for i in range(len(n))]))
Buggy code:
N = int(input())
m = float("inf")

for A in range(N):
  summ = 0
  B = N-A
  
  while A >0:
    summ += A%10
    A //=10
  while B >0:
    summ += B%10
    B//=10
  if summ < m:
    m = summ
print(m)
  
  



Fixed code:
N = int(input())
m = float("inf")
 
for A in range(1,N):
  summ = 0
  B = N-A
  
  while A >0:
    summ += A%10
    A //=10
  while B >0:
    summ += B%10
    B//=10
  if summ < m:
    m = summ

print(m)
Buggy code:
n = input()
def sum_keta(m):
	sum_wa = 0
	while m>0:
		sum_wa = sum_wa + m%10
		m = int(m/10)

	return sum_wa

if sum_keta(n) == 1:
	print(10)
else:
	print(sum_keta(n))


Fixed code:
n = int(input())
def sum_keta(m):
	sum_wa = 0
	while m>0:
		sum_wa = sum_wa + m%10
		m = int(m/10)

	return sum_wa

if sum_keta(n) == 1:
	print(10)
else:
	print(sum_keta(n))
Buggy code:
N = int(input())
ans = float("inf")
for i in range(N):
    if sum(map(int, str(i))) + sum(map(int, str(N-i))) < ans:
        ans = sum(map(int, str(i))) + sum(map(int, str(N-i)))
print(ans)

Fixed code:
N = int(input())
ans = float("inf")
for i in range(1,N):
    if sum(map(int, str(i))) + sum(map(int, str(N-i))) < ans:
        ans = sum(map(int, str(i))) + sum(map(int, str(N-i)))
print(ans)
Buggy code:
N = int(input())
minmum = 10**5
def digitSum(n):
    s = str(n)
    array = list(map(int, list(s)))
    return sum(array)

for i in range(1, N):
    for j in range(1, N):
        if i + j == N:
            min_sum = digitSum(i) + digitSum(j)
            if min_sum < minmum:
                minmum = min_sum

print(minmum)

Fixed code:
N = int(input())
minmum = 10**5
def digitSum(n):
    s = str(n)
    array = list(map(int, list(s)))
    return sum(array)

for i in range(1, N):
    j = N - i
    min_sum = digitSum(i) + digitSum(j)
    if min_sum < minmum:
        minmum = min_sum

print(minmum)
Buggy code:
n=int(input())
ans=0
def calc(a,b):
  res=0
  for i in range(len(str(a))):
    res+=int(str(a)[i])
  for i in range(len(str(b))):
    res+=int(str(b)[i])
  return res
  
for i in range(1,n//2+1):
  a=i
  b=n-a
  ans=min(ans,calc(a,b))
print(ans)

Fixed code:
n=int(input())
ans=10**6
def calc(a,b):
  res=0
  for i in range(len(str(a))):
    res+=int(str(a)[i])
  for i in range(len(str(b))):
    res+=int(str(b)[i])
  return res
  
for i in range(1,n//2+1):
  a=i
  b=n-a
  ans=min(ans,calc(a,b))
print(ans)
Buggy code:
N = list(map(int, list(input())))
s = sum(N)

if s is 1:
    print(10)
else:
    print(sum)

Fixed code:
N = list(map(int, list(input())))

s = sum(N)

if s is 1:
  print(10)
else:
  print(s)
Buggy code:
ans=float("INF")
n=int(input())
l=[]
s=0
for i in range(n//2+1):
  ans=min(sum(list(map(int,list(str(i)))))+sum(list(map(int,list(str(n-i))))),ans)
print(ans)

Fixed code:
ans=float("INF")
n=int(input())

s=0
for i in range(1,n//2+1):
  ans=min(sum(list(map(int,list(str(i)))))+sum(list(map(int,list(str(n-i))))),ans)
print(ans)
Buggy code:
a = int(input())
mi=[]
for i in range(1,a+1):
    x=0
    y=0
    j = a - i
    for ii in str(i):
        x+=int(ii)
    for jj in str(j):
        y+=int(jj)
    mi.append(x+y)
print(min(mi))

Fixed code:
a = int(input())
mi=[]
for i in range(1,a):
    x=0
    y=0
    j = a - i
    for ii in str(i):
        x+=int(ii)
    for jj in str(j):
        y+=int(jj)
    mi.append(x+y)
print(min(mi))
Buggy code:

def main():

    if sum(list(map(int,list(input())))) !=1:
        print(sum(list(map(int,list(input())))))
    else:
        print(10)
 

    
if __name__== "__main__":
    main() 











Fixed code:

def main():
    ans = sum(list(map(int,list(input()))))
    if  ans!=1:
        print(ans)
    else:
        print(10)
 

    
if __name__== "__main__":
    main()
Buggy code:
n = int(input())
a = 0
for i in range(len(n)):
    a += n[i]
if a == 1:
    print(10)
else:
    print(a)

Fixed code:
n = input()
a = 0
for i in range(len(n)):
    a += int(n[i])
if a == 1:
    print(10)
else:
    print(a)
Buggy code:
def gen(n):
  if n < 10:
    yield n
  else:
    for m in gen(n/10):
      yield m
    yield n%10

N=int(input())

A=0
B=N-A
min_val=N
while A <= N:
	A_num=[int(i) for i in gen(A)]
	B_num=[int(i) for i in gen(B)]
	#print('A='+str(A),end=' ')
	#print('B='+str(B),end=' ')
	#print(A_num,end=' ')	
	#print(B_num,end=' ')
	val=sum(A_num)+sum(B_num)
	#print(val)
	if val < min_val:
		min_val=val
		#print(val)
	A+=1
	B=N-A

print(min_val)

Fixed code:
def gen(n):
  if n < 10:
    yield n
  else:
    for m in gen(n/10):
      yield m
    yield n%10

N=int(input())

A=1
B=N-A
min_val=N
while A < N:
	A_num=[int(i) for i in gen(A)]
	B_num=[int(i) for i in gen(B)]
	#print('A='+str(A),end=' ')
	#print('B='+str(B),end=' ')
	#print(A_num,end=' ')	
	#print(B_num,end=' ')
	val=sum(A_num)+sum(B_num)
	#print(val)
	if val < min_val:
		min_val=val
		#print(val)
	A+=1
	B=N-A

print(min_val)
Buggy code:
n = int(input())
nmin = 10000000
for n1 in range(n+1):
    n2 = n-n1
    nsum = sum(map(int, list(str(n1))))+sum(map(int, list(str(n2))))

    if nmin > nsum:
        nmin = nsum
print(nmin)

Fixed code:
n = int(input())
nmin = 10000000
for n1 in range(1,n):
    n2 = n-n1
    nsum = sum(map(int, list(str(n1))))+sum(map(int, list(str(n2))))

    if nmin > nsum:
        nmin = nsum
print(nmin)
Buggy code:
N = int(input())
min = 100000000000000
for i in range(1, (N+1)//2):
   A = str(i)
  B = str(N - i)
  ref = 0
  for a in A:
    ref += int(a)
  for b in B:
    ref += int(b)
  if ref < min:
    min = ref
print(min)

Fixed code:
N = int(input())
min = 100000000000000
for i in range(1, N):
  A = str(i)
  B = str(N - i)
  ref = 0
  for a in A:
    ref += int(a)
  for b in B:
    ref += int(b)
  if ref < min:
    min = ref
print(min)
Buggy code:
from numpy import inf
n=int(input())
ans=inf
for i in range(n):
    ans=min(ans,sum(list(map(int, list(str(n-i)))))+sum(list(map(int, list(str(i))))))
print(ans)

Fixed code:
from numpy import inf
n=int(input())
ans=inf
for i in range(n-1):
    ans=min(ans,sum(list(map(int, list(str(n-i-1)))))+sum(list(map(int, list(str(i+1))))))
print(ans)
Buggy code:
n = int(input())

box =[]

for x in range(1,n):
    for y in range(1,n):
        if x + y == n:
            xsum = sum(list(map(int, str(x))))
            ysum = sum(list(map(int, str(y))))
            box.append(xsum + ysum)
            
print(min(box))
            

Fixed code:
n = int(input())

box =[]

for x in range(1,n):
    y = n -x
    xsum = sum(list(map(int, str(x))))
    ysum = sum(list(map(int, str(y))))
    box.append(xsum + ysum)
            
    
            
print(min(box))
Buggy code:
n=int(input())
def num(x):
  rec=0
  while x>0:
    rec+=x%10
    rec//=10
ans=10**18
for i in range(1,n//2):
  ans=min(ans,num(i)+num(n-i))
print(ans)

Fixed code:
n=int(input())
def num(x):
  rec=0
  while x>0:
    rec+=x%10
    x//=10
  return rec
ans=10**18
for i in range(1,(n+3)//2):
  ans=min(ans,num(i)+num(n-i))
print(ans)
Buggy code:
N=int(input())
a=10e6
for i in range(N//2+1):
  A=i;B=N-i
  numA=sum([int(i) for i in list(str(A))])
  numB=sum([int(i) for i in list(str(B))])
  a=min(numA+numB,a)
print(a)


Fixed code:
N=int(input())
a=10e6
for i in range(1,N//2+1):
  A=i;B=N-i
  numA=sum([int(i) for i in list(str(A))])
  numB=sum([int(i) for i in list(str(B))])
  a=min(numA+numB,a)
print(a)
Buggy code:
N = int(input())
ans = N

for i in range(N):
  j = N-i
  ist = str(i)
  jst = str(j)
  iarray = list(map(int ,ist))
  jarray = list(map(int ,jst))
  isum = sum(iarray)
  jsum = sum(jarray)
  if isum + jsum < ans:
    ans = isum + jsum
print(ans)
    
    
  

Fixed code:
N = int(input())
ans = N

for i in range(1,N):
  j = N-i
  ist = str(i)
  jst = str(j)
  iarray = list(map(int ,ist))
  jarray = list(map(int ,jst))
  isum = sum(iarray)
  jsum = sum(jarray)
  if isum + jsum < ans:
    ans = isum + jsum
print(ans)
Buggy code:
def sumOfEach(x):
    array = list(str(x))
    ret = 0
    for z in array:
        ret += int(z)
    return ret

n = int(input())
a = 1
b = sumOfEach(n - a)
print(a + b)

#minOfsum = 10 ** 5
#for a in range(1, int(n / 2) + 1):
#    b = n - a
#    #print(a, b)
#    sumOfEachA = sumOfEach(a)
#    sumOfEachB = sumOfEach(b)
#    sumOfTwo = sumOfEachA + sumOfEachB
#    #sumOfTwo = sumOfEach(a) + sumOfEach(b)
#    if sumOfTwo < minOfsum:
#        minOfsum = sumOfTwo
#print(minOfsum)
#



Fixed code:
def sumOfEach(x):
    array = list(str(x))
    ret = 0
    for z in array:
        ret += int(z)
    return ret

n = int(input())
minOfsum = 10 ** 5
for a in range(1, int(n / 2) + 1):
    b = n - a
    #print(a, b)
    sumOfEachA = sumOfEach(a)
    sumOfEachB = sumOfEach(b)
    sumOfTwo = sumOfEachA + sumOfEachB
    #sumOfTwo = sumOfEach(a) + sumOfEach(b)
    if sumOfTwo < minOfsum:
        minOfsum = sumOfTwo
print(minOfsum)
Buggy code:
N = int(input())

ans = N
for A in range(1,N):
    B = N - A
    A_str = str(A)
    B_str = str(B)
    A_li = [int(A_str[i]) for i in len(A_str)]
    B_li = [int(B_str[i]) for i in len(B_str)]
    s = sum(A_li) + sum(B_li)
    if s < ans:
        ans = s

print(ans)

Fixed code:
N = int(input())

ans = N
for A in range(1,N):
    B = N - A
    A_str = str(A)
    B_str = str(B)
    A_li = [int(A_str[i]) for i in range(len(A_str))]
    B_li = [int(B_str[i]) for i in range(len(B_str))]
    s = sum(A_li) + sum(B_li)
    if s < ans:
        ans = s

print(ans)
Buggy code:
def resolve():
    ans = 100000
    n = int(input())

    for a in range(1, (n // 2) + 1):
        b = n - a
        sum = 0

        while (a > 0) or (b > 0):
            sum += (a % 10)
            a = a // 10
            sum += (b % 10)
            b = b // 10

        if sum < ans:
            ans = sum

    print(ans)

Fixed code:
ans = 100000
n = int(input())

for a in range(1, (n // 2) + 1):
  b = n - a
  sum = 0

  while (a > 0) or (b > 0):
    sum += (a % 10)
    a = a // 10
    sum += (b % 10)
    b = b // 10

  if sum < ans:
    ans = sum

print(ans)
Buggy code:
N = int(input())
L = []
for i in range(N):
	a = i + 1
	b = N - i - 1
	s = sum(list(map,(int, list(str(a))))) + sum(list(map,(int, list(str(b)))))
	L.append(s)
print(min(L))

Fixed code:
N = int(input())
L = []
for i in range(N - 1):
	a = list(str(i + 1))
	b = list(str(N - i - 1))
	asum = sum(list(map(int, a)))
	bsum = sum(list(map(int, b)))
	
	L.append(asum + bsum)
print(min(L))
Buggy code:
def findSumOfDigits(num):
  sum = 0
  while num > 0:
    sum += num % 10
    num //= 10
  return sum
  
if __name__ == '__main__':
  N = int(input())
  min_total = 100
  for i in range(N + 1):
    A = i
    B = N - A
    total = findSumOfDigits(A) + findSumOfDigits(B)
    if total < min_total:
      min_total = total
  print(min_total)

Fixed code:
def findSumOfDigits(num):
  sum = 0
  while num > 0:
    sum += num % 10
    num //= 10
  return sum
  
if __name__ == '__main__':
  N = int(input())
  min_total = 1000
  for i in range(1, N):
    A = i
    B = N - A
    total = findSumOfDigits(A) + findSumOfDigits(B)
    if total < min_total:
      min_total = total
  print(min_total)
Buggy code:
n=int(input())
count = sum([int(j) for j in str(0)]) + sum([int(j) for j in str(n)])
for i in range(-(-n//2)+1):
    a = sum([int(j) for j in str(i)])
    b = sum([int(j) for j in str(n-i)])
    if count > a + b:
        count = a + b
print(count)


Fixed code:
n=int(input())
count = sum([int(j) for j in str(1)]) + sum([int(j) for j in str(n-1)])
for i in range(1,-(-n//2)+1):
    a = sum([int(j) for j in str(i)])
    b = sum([int(j) for j in str(n-i)])
    if count > a + b:
        count = a + b
print(count)
Buggy code:
#coding : utf8

def digitSum(number):
    s = str(number)
    li = list(map(int,list(s)))
    return sum(li)

if __name__ == '__main__':
    inputNum = int(input())
    minimum = inputNum

    for i in range(int(inputNum/2)):
        temp = digitSum(i) + digitSum(inputNum-i)
        if(minimum > temp):
            minimum = temp

    print(minimum)


Fixed code:
#coding : utf8

def digitSum(number):
    s = str(number)
    li = list(map(int,list(s)))
    return sum(li)

if __name__ == '__main__':
    inputNum = int(input())
    minimum = inputNum

    for i in range(1,int(inputNum/2+1)):
        temp = digitSum(i) + digitSum(inputNum-i)
        if(minimum > temp):
            minimum = temp

    print(minimum)
Buggy code:
n = int(input())
min = 100
a_sum = 0
b_sum = 0

for a in range(1, n):
  b = n-a
  while a >= 1:
    a_sum += a%10
    a = a//10
  
  while b >= 1:
    b_sum += b%10
    b = b//10
  
  if a_sum + b_sum < min:
    min = a_sum + b_sum

print(min)

Fixed code:
n = int(input())
min = 100
a_sum = 0
b_sum = 0

for a in range(1, n):
  b = n-a
  while a >= 1:
    a_sum += a%10
    a = a//10
  
  while b >= 1:
    b_sum += b%10
    b = b//10
  
  if a_sum + b_sum < min:
    min = a_sum + b_sum
  
  a_sum = 0
  b_sum = 0

print(min)
Buggy code:
N = int(input())

ans = float("inf")

A = 0
B = N
for i in range(N//2):

    A += 1
    B -= 1

    if A + B > N:
        break

    else:

        s_a = str(A)
        s_b = list(str(B))

        a = [int(i) for i in s_a]
        b = [int(i) for i in s_b]

        ans = min(ans, sum(a)+sum(BytesWarning))

print(ans)


Fixed code:
N = int(input())

ans = float("inf")

A = 0
B = N
for i in range(N//2):

    A += 1
    B -= 1

    if A + B > N:
        break

    else:

        s_a = str(A)
        s_b = list(str(B))

        a = [int(i) for i in s_a]
        b = [int(i) for i in s_b]

        ans = min(ans, sum(a)+sum(b))

print(ans)
Buggy code:
a,b=map(int,input(),split())
list=[a+b,a-b,a*b]
print(max(list))

Fixed code:
a, b = list(map(int, input().split()))

print(max([a + b, a - b, a * b]))
Buggy code:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))


n,k = map(int,input().split())
print(max(m+k,n-k,n*k))

Fixed code:
#n = int(input())
#n,k = map(int,input().split())
#x = list(map(int,input().split()))
 
 
n,k = map(int,input().split())
print(max(n+k,n-k,n*k))
Buggy code:
A, B= map(int, input().split())
ans = max(A+B, A-B, A*B)
print async 

Fixed code:
A, B= map(int, input().split())
ans = max(A+B, A-B, A*B)
print(ans)
Buggy code:
A, B = list(map(int, input().split()))
print(max(A + B, max(A - B.A * B)))


Fixed code:
A, B = list(map(int, input().split()))
print(max(A + B, max(A - B, A * B)))
Buggy code:
a, b = map(int, input().split())
 print(max(a+b,max(a-b,a*b)))

Fixed code:
a, b = map(int, input().split())
print(max(a+b,max(a-b,a*b)))
Buggy code:
a,b = map(int,input().split())
print(max([a+b,a-b,a*b])

Fixed code:
a,b = map(int,input().split())
print(max([a+b,a-b,a*b]))
Buggy code:
a,b = list(map(int,input().split()))
print(max(a-b,max(a+b,a*b))

Fixed code:
a, b = map(int, input().split())
print(max(max(a+b, a-b), a*b))
Buggy code:
A, B = map(int, input().split())
print(max(A+B, A=B, A*B))

Fixed code:
A, B = map(int,input().split())
print(max(A+B, A-B, A*B))
Buggy code:
A, B = map(int, input().split())

add = A + B
sub = A - b
mui = A * B

print(max(add, sub, mui))

Fixed code:
A, B = map(int, input().split())
 
add = A + B
sub = A - B
mui = A * B
 
print(max(add, sub, mui))
Buggy code:
a, b = map(int, input().split())
max(a + b, a - b, a * b)


Fixed code:
a,b=map(int,input().split())
print(max(a+b,a-b,a*b))
Buggy code:
s = list(map(int,input().split( ))
karians = []
karians.append(karians[0]-karians[1])
karians.append(karians[0]+karians[1])
karians.append(karians[0]*karians[1])
ans = max(karians)
print(ans)

Fixed code:
s = list(map(int,input().split( )))
x = []
x.append(s[0]+s[1])
x.append(s[0]-s[1])
x.append(s[0]*s[1])
ans = max(x)
print(ans)
Buggy code:
A, B = map(int, input().split())
print(max([A*B, A+B, A-B])

Fixed code:
A, B = map(int, input().split())
print(max([A*B, A+B, A-B]))
Buggy code:
a,b=map(int,input().split())
p=a+b
m=a-b
j=a*b
i=p
if i<m:
  i=m
if i<j:
  i=j
print i

Fixed code:
a,b=map(int,input().split())
p=a+b
m=a-b
j=a*b
i=p
if i<m:
  i=m
if i<j:
  i=j
print (i)
Buggy code:
l = list(map(int, input().split()))
a = l[0]
b = l[1]

ans1 = a + b
ans2 = a - b
ans3 = a * b

print(max(ans1, ans2, ans3)

Fixed code:
l = list(map(int, input().split()))
a = l[0]
b = l[1]

ans1 = a + b
ans2 = a - b
ans3 = a * b

print(max(ans1, ans2, ans3))
Buggy code:
A, B = int(input().split())

max = -1000
if A + B > max:
    max = A + B
if A - B > max:
    max = A - B
if A * B > max:
    max = A * B
print(max)

Fixed code:
A, B = map(int, input().split())

max = -1000
if A + B > max:
    max = A + B
if A - B > max:
    max = A - B
if A * B > max:
    max = A * B
print(max)
Buggy code:
A,B=map(int,input().split())
S=A+B
T=A-B
U=A*B
if S>T & S>U:
    print(S)
elif T>S & T>U:
    print(T)
else:
    print(U)

Fixed code:
A,B=map(int,input().split())
S=A+B
T=A-B
U=A*B
if (S>=T) & (S>=U):
    print(S)
elif (T>=S) & (T>=U):
    print(T)
else:
    print(U)
Buggy code:
a,b=int(input().split())

print(max(a+b,a-b,a*b))

Fixed code:
a,b=input().split()
a=int(a)
b=int(b)

print(max(a+b,a-b,a*b))
Buggy code:
A,B=map(int,input().split)
print(max(A+B,A-B,A*B))

Fixed code:
A,B = map(int,input().split())

print(max(A+B,A-B,A*B))
Buggy code:
a,b = map(int, input().split())
print(max(a+b,max(a-b,a*b))

Fixed code:
a,b = list(map(int,input().split()))
print(max(a+b,a-b,a*b))
Buggy code:
a, b = map(int, input().split())

ans = [a+b, a-b, a*b]
print(max[ans])

Fixed code:
a,b = map(int, input().split())
ans = [a+b, a-b, a*b]
print(max(ans))
Buggy code:
a, b = map(int,input().split())

print(max(a + b, a - b, a * b)
      
      

Fixed code:
a,b = map(int, input().split())
print(max(a+b, a*b, a-b))
Buggy code:
A,B = map(int,input().split())

a1 = A + B
a2 = A - B
a3 = A * B

if a1 >= a2 and a1 >= a3:
	print(a1)
elif a2 >= a1 and a>= a3:
	print(a2)
elif a3 >= a1 and a3 >=a2:
	print(a3)

Fixed code:
A,B = map(int,input().split())

a1 = A + B
a2 = A - B
a3 = A * B

if a1 >= a2 and a1 >= a3:
	print(a1)
elif a2 >= a1 and a2>= a3:
	print(a2)
elif a3 >= a1 and a3 >= a2:
	print(a3)
Buggy code:
a,b = map(int,input().split())
print(max(a-b,a+b,a*B))

Fixed code:
a, b = map(int,input().split())
print(max(a+b,a-b,a*b))
Buggy code:
a,b = map(int, input().split())
print(max(a+b, a-b, a*b)

Fixed code:
a,b=map(int,input().split());print(max(a+b,a-b,a*b))
Buggy code:
x, y = [int(s) for s in input().split()]
max([x + y, x - y, x * y])


Fixed code:
x, y = [int(s) for s in input().split()]
print(max([x + y, x - y, x * y]))
Buggy code:
A, B = map(int, input().split())
print(max([A+B, A-B, A*B])

Fixed code:
A, B = map(int, input().split())

tmp = [A+B, A-B, A*B]
print(max(tmp))
Buggy code:
a,b=map(int,input(),input().split())
print(max(a+b,a-b,a*b))

Fixed code:
a,b = map(int,input().split())
print(max(a+b,max(a-b,a*b)))
Buggy code:
a, b = map(int, input().split())
print([a+b, a-b, a*b])

Fixed code:
a, b = map(int, input().split())
print(max([a+b,a-b,a*b]))
Buggy code:
a,b=map(int,input().split())
print(max(a+b,a=b,a*b))

Fixed code:
a, b = map(int, input().split())

print(max(a+b,a-b,a*b))
Buggy code:
A,B=map(int,input().split(' '))
print(max(A*B,A+B))

Fixed code:
A,B=map(int,input().split(' '))
print(max(A*B,A+B,A-B))
Buggy code:
a,b=map(int,input().split())
print(max[a+b,a-b,a*b])

Fixed code:
a,b = map(int,input().split())
c = [a + b,a - b,a * b]
print(max(c))
Buggy code:
a,b=map(int,input().split());print(max(a+b,a-b a*b))

Fixed code:
a, b = map(int,input().split())
print(max(a+b, a-b,a*b))
Buggy code:
a, b = map(int, input().split())
print(max[a*b, a-b, a+b])

Fixed code:
a, b = map(int, input().split())
print(max([a*b, a-b, a+b]))
Buggy code:

a,b = map(int().input().split())
print(max(a+b,a-b,a*b))

Fixed code:
a,b=map(int, input().split())
print(max(a+b,a-b,a*b))