qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a=[]
for i in range(4)
 a.append(int(input())
print(min(a[0],a[1])+min(a[2],a[3]))

Fixed code:
a=[]
for i in range(4):
 a.append(int(input()))
print(min(a[0],a[1])+min(a[2],a[3]))
Buggy code:
a  = [ i for i in range(4)]
for i in range(4):
    a[i]=int(input())
print(max(a[0],a[1])+max(a[2],a[3]))

Fixed code:
a  = [ i for i in range(4)]
for i in range(4):
    a[i]=int(input())
print(min(a[0],a[1])+min(a[2],a[3]))
Buggy code:
n = [int,input() for i in range(1,5)]

x = min(n[1], n[2])+ min(n[3], n[4])

print(x)

Fixed code:
n = [int(input()) for i in range(1,5)]

x = min(n[0], n[1])+ min(n[2], n[3])

print(x)
Buggy code:
l = [int(input()) for i in range(1, 4)]
print(min(l[0], l[1]) + min(l[2], l[3]))


Fixed code:
l = [int(input()) for i in range(1, 5)]
print(min(l[0], l[1]) + min(l[2], l[3]))
Buggy code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())

if A>B:
	if C>D:
		print(B+D)
	else:
		print(B+C)
else:
	if C>D:
		print(B+D)
	else:
		print(B+C)


Fixed code:

A=int(input())
B=int(input())
C=int(input())
D=int(input())

if A>B:
	if C>D:
		print(B+D)
	else:
		print(B+C)
else:
	if C>D:
		print(A+D)
	else:
		print(A+C)
Buggy code:
l= sorted([int(input()) for _ in range(2)])
m=sorted([int(input()) for _ in range(2)])
print(l,m)
ans= min(x+y for x,y in zip(l,m))
print(ans)

Fixed code:
l= sorted([int(input()) for _ in range(2)])
m=sorted([int(input()) for _ in range(2)])

ans= min(x+y for x,y in zip(l,m))
print(ans)
Buggy code:
A=min([int(input()) for i in range(2)])
print(A+min([int(input()) for i in range(2)])

Fixed code:
A=min([int(input()) for i in range(2)])
print(A+min([int(input()) for i in range(2)]))
Buggy code:
#n = int(input())
#a,b = map(int,input().split())
#a_L = list(map(int,input().split()))
a_L = []
for _ in range(4):
    a_L.append(int(input()))
print(min(a_L[0]+a_L[1])+min(a_L[2]+a_L[3]))

Fixed code:
#n = int(input())
#a,b = map(int,input().split())
#a_L = list(map(int,input().split()))
a_L = []
for _ in range(4):
    a_L.append(int(input()))
print(min(a_L[0],a_L[1])+min(a_L[2],a_L[3]))
Buggy code:
a=[int(input(i)) for i in range(2)]
b=[int(input(i)) for i in range(2)]
print(min(a)+min(b))

Fixed code:
a=[int(input()) for i in range(2)]
b=[int(input()) for i in range(2)]
print(min(a)+min(b))
Buggy code:
aa = [int(input()) for _ in range(4)]

a,b,c,d = map(aa)

print(min(a,b) + min(c,d))

Fixed code:
aa = [input() for _ in range(4)]

a,b,c,d = map(int, aa)

print(min(a,b) + min(c,d))
Buggy code:
a=int,input()
b=int,input()
c=int,input()
d=int,input()
sum1=0
sum2=0
if a<=b:
    sum1=a
else:
    sum1=b
if c<=d:
    sum2=c
else:
    sum2=d
print(sum1+sum2)

Fixed code:
a=int(input())
b=int(input())
c=int(input())
d=int(input())
sum1=0
sum2=0
if a<=b:
    sum1=a
else:
    sum1=b
if c<=d:
    sum2=c
else:
    sum2=d
print(sum1+sum2)
Buggy code:
A = input(int())
B = input(int())
C = input(int())
D = input(int())
train = [A,  B]
bus = [C, D]
ans = min(train) + min(bus)
print(ans)


Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())
train = [A,  B]
bus = [C, D]
ans = min(train) + min(bus)
print(ans)
Buggy code:
a,b,c,d=[input() for _ in range(4)]
print(min(a,b)+min(c,d))

Fixed code:
a,b,c,d=[int(input()) for _ in range(4)]
print(min(a,b)+min(c,d))
Buggy code:
l =[]
s = []
for i in range(4):
  l.appned(int(input()))
if l[0] <= l[1]:
  s.appned(l[0])
else:
  s.append(l[1])
if l[2] <= l[3]:
  s.appned(l[2])
else:
  s.appned(l[3])
print(sum(s))

Fixed code:
l =[]
s = []
for i in range(4):
  l.append(int(input()))
if l[0] <= l[1]:
  s.append(l[0])
else:
  s.append(l[1])
if l[2] <= l[3]:
  s.append(l[2])
else:
  s.append(l[3])
print(sum(s))
Buggy code:
ab=[int(i) for i in range(2)]
cd=[int(i) for i in range(2)]
print(min(ab)+min(cd))

Fixed code:
ab=[int(input()) for i in range(2)]
cd=[int(input()) for i in range(2)]
print(min(ab)+min(cd))
Buggy code:
a = input()
b = input()
c = input()
d = input()

print(min(a, b) + min(c, d))



Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

print(min(a, b) + min(c, d))
Buggy code:
# -*- coding: utf-8 -*-

a = int(input())
b = int(input())
c = int(input())
d = int(input())

train = 0
bus = 0

train = a if a < b else b
bus = c if c < b else d

print(train + bus)

Fixed code:
# -*- coding: utf-8 -*-

a = int(input())
b = int(input())
c = int(input())
d = int(input())

train = 0
bus = 0

train = a if a < b else b
bus = c if c < d else d

print(train + bus)
Buggy code:
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a,b,c,d = map(int,input().split())
print(min(a,b)+min(c,d))

Fixed code:
#!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a = int(input())
b = int(input())
c = int(input())
d = int(input())

print(min(a,b)+min(c,d))
Buggy code:
train1=int(input())
train2=int(input())
bus1=int(input())
bus2=int(input())
print(min(train1,train2)+min(bus1+bus2))

Fixed code:
train1=int(input())
train2=int(input())
bus1=int(input())
bus2=int(input())
print(min(train1,train2)+min(bus1,bus2))
Buggy code:
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, c, d = map(int, readline().split())
print(min(a, b) + min(c + d))


Fixed code:
"""
author : halo2halo
date : 24, Jan, 2020
"""

import sys

# import numpy as np

read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

a, b, c, d = map(int, read().split())
print(min(a, b) + min(c,d))
Buggy code:
A, B, C, D = int(input())

train = [A,B]
bus = [C,D]

print(min(train) + min(bus))

Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

train = [A,B]
bus = [C,D]

print(min(train) + min(bus))
Buggy code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())
print(min(A,B)+min(C+D))

Fixed code:
A= int(input())
B= int(input())
C= int(input())
D= int(input())
print(min(A,B) + min(C,D))
Buggy code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

print(min[a,b] + min[c,d])

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

print(min([a,b]) + min([c,d]))
Buggy code:
a=[]
for _ in range(4):
	a.append(int(input())

print(min(a[0],a[1])+min(a[2],a[3]))

Fixed code:
a=[]
for _ in range(4):
	a.append(int(input()))

print(min(a[0],a[1])+min(a[2],a[3]))
Buggy code:
a = input()
b = input()
c = input()
d = input()
print(min(a, b) + min(c, d))

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a,b) + min(c,d))
Buggy code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())
print(min(A+C,A+D,B+c,B+D))

Fixed code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())
print(min(A+C,A+D,B+C,B+D))
Buggy code:
A,B,C,D = [int(input) for _ in range(4)]

print(min(A,B)+min(C,D)


Fixed code:
A,B,C,D = [int(input()) for _ in range(4)]

print(min(A,B)+min(C,D))
Buggy code:
A=input()
B=input()
C=input()
D=input()
if A<=B:
  min1=A
else:
  min1=B
if C<=D:
  min2=C
else:
  min2=D
print(min1+min2)

Fixed code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())
if A<=B:
  min1=A
else:
  min1=B
if C<=D:
  min2=C
else:
  min2=D
  
print(min1+min2)
Buggy code:
a, b, c, c = [int(input()) for i in range(4)]
print(min(a,b) + min(c,d))

Fixed code:
a, b, c, d = [int(input()) for i in range(4)]
print(min(a,b) + min(c,d))
Buggy code:
k = []
for i in range(4):
    k.append(int(input()))
print(min(k[0],k[1])+min(k[2]+k[3]))


Fixed code:
k = []
for i in range(4):
    k.append(int(input()))
a = min(k[0],k[1]) + min(k[2],k[3])
print(a)
Buggy code:
A = input()
B = input()
C = input()
D = input()

if A <= B:
    train = A
else:
    train = B
if C <= D:
    bus = C
else:
    bus = D

answer = train + bus
print(answer)

Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

if A <= B:
    train = A
else:
    train = B
if C <= D:
    bus = C
else:
    bus = D

answer = (train + bus)
print(answer)
Buggy code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a,b)+min(c+d))

Fixed code:
a = (int)(input())
b = (int)(input())
c = (int)(input())
d = (int)(input())
print(min(a,b)+min(c,d))
Buggy code:
a = [int(input()) for i in range(4)]
print(min(a[0:1]) + min(a[2:3]))

Fixed code:
a = [int(input()) for i in range(4)]
print(min(a[0:2]) + min(a[2:4]))
Buggy code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())


print(min(A+B)+min(C+D))


Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

print (min(A,B) + min(C,D))
Buggy code:
a = input()
b = input()
c = input()
d = input()

print(min(a,b)+min(c,d))

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a + c, a + d, b + c, b + d))
Buggy code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

if a> b:
  num1 = b
else:
  num1 = a
if c > d:
  num2 = d
else:
  num2 = c
print(nu1+num2)

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

if a> b:
  num1 = b
else:
  num1 = a
if c > d:
  num2 = d
else:
  num2 = c
print(num1+num2)
Buggy code:
A,B,C,B = [int(input()) for i in range(4)]
print(min(A,B) + min(C,D))

Fixed code:
A,B,C,D = [int(input()) for i in range(4)]
print(min(A,B) + min(C,D))
Buggy code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())

print(min(A,B)+min(B,C))

Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())
print(min(A,B)+min(C,D))
Buggy code:
print(sum([min([int(input())for i in[1,2]]for j in[1,2]))

Fixed code:
print(sum([min([int(input())for i in[1,2]])for j in[1,2]]))
Buggy code:
a = int(input()); b = int(input()); c = int(input()); d = int(input())
print(min(a+b, a+d, c+b, c+d))

Fixed code:
a = int(input()); b = int(input()); c = int(input()); d = int(input())
print(min(a+c, a+d, b+c, b+d))
Buggy code:
a=int(input())
b=int(input())
c=int(input())
d=int(input())
if (a+c)<(b+d):
  print(a+c)
else:
  print(b+d)
     

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

print((a if a < b else b) + (c if c < d else d))
Buggy code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

A, B, C, D = MAP()

print(min(A, B)+min(C, D))


Fixed code:
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

A = INT()
B = INT()
C = INT()
D = INT()

print(min(A, B)+min(C, D))
Buggy code:
L=[int(input()) for _ in range(4)]
print(min(L[0]+L[2],L[1]+L[3]))

Fixed code:
lst = [int(input()) for _ in range(4)]

print(min(lst[0], lst[1]) + min(lst[2], lst[3]))
Buggy code:
tmp = []
for i in range(4):
  tmp.append(int(input()))
  
ptint(min(tmp[0], tmp[1])+min(tmp[2], tmp[3]))

Fixed code:
tmp = []
for i in range(4):
  tmp.append(int(input()))
  
print(min(tmp[0], tmp[1])+min(tmp[2], tmp[3]))
Buggy code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

print(min(A+B)+min(C+D))

Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())
 
print(min(A,B)+min(C,D))
Buggy code:
a,b,c.d=(int(input()) for i in range(4))
ans=min(a,b)+min(c,d)
print(ans)

Fixed code:
a,b,c,d=(int(input()) for i in range(4))
ans=min(a,b)+min(c,d)
print(ans)
Buggy code:
a,b,c,d=[int(input()) for i in range(4)]
ls = list[a+c,a+d,b+c,b+d]
print(min(ls))

Fixed code:
a,b,c,d=[int(input()) for i in range(4)]
print(min(a+c,a+d,b+c,b+d))
Buggy code:
a,b,c,d = [int(input) for _ in renge(4)]
print(min(a,b) + min(c,d))


Fixed code:
a,b,c,d = [int(input()) for _ in range(4)]
print(min(a,b) + min(c,d))
Buggy code:
a=input()
a=int(a)
b=input()
b=int(b)
c=input()
c=int(c)
d=input()
d=int(d)
if(b+c<=a+d):
  print(b+c)
elif(b+d<=a+c):
  print(b+d)
elif(a+c<=b+d):
    print(a+c)
else:
    print(a+d)
    


  


        


Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

if a<b:
    if c<d:
        print(a+c)
    else:
        print(a+d)
else:
    if c<d:
        print(b+c)
    else:
        print(b+d)
Buggy code:
l=[int(input)for _ in range(n)]
print(min(l[0],l[1])+min(l[2],l[3]))

Fixed code:
l=[int(input()) for _ in range(4)]
print(min(l[0],l[1])+min(l[2],l[3]))
Buggy code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())

print(min(A,B)+min(C+D))

Fixed code:
A=int(input())
B=int(input())
C=int(input())
D = int(input())
print(min(A,B)+min(C,D))
Buggy code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a, c)+min(b, d))

Fixed code:
a=int(input())
b=min(int(input()),a)
c=int(input())
d=min(int(input()),c)
print(b+d)
Buggy code:
import sys
input = sys.stdin.readline
a=int(input()
b=int(input()
c=int(input()
d=int(input()
print(min(a,b)+min(c,d))


Fixed code:
import sys
input = sys.stdin.readline
a=int(input())
b=int(input())
c=int(input())
d=int(input())
print(min(a,b)+min(c,d))
Buggy code:
a,b, c, d = [int(input()) for i in range(4)]
print(min(a, c) + min(b, d))

Fixed code:
a, b, c, d = [int(input()) for _ in range(4)]
print(min(a, b)+min(c, d))
Buggy code:
# -*- coding: utf-8 -*-
A = int(input())
B = int(input())
C = int(input())
D = int(input())

if A>=B and C>=D:
    print(B+D)
if A>=B and C<=D:
    print(B+C)
if A<=B and C>=D:
    print(A+D)
if A<=B and C<=D:
    print(A+C)


Fixed code:
# -*- coding: utf-8 -*-
A = int(input())
B = int(input())
C = int(input())
D = int(input())

if A>=B and C>=D:
    print(B+D)
elif A>=B and C<=D:
    print(B+C)
elif A<=B and C>=D:
    print(A+D)
elif A<=B and C<=D:
    print(A+C)
Buggy code:
A=int(input())
B=int(input())
c=int(input())
D=int(input())
print(min(A,B)+min(C,D))

Fixed code:

A = int(input())
B = int(input())
C = int(input())
D = int(input())

print (min(A,B)+min(C,D))
Buggy code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
ans = 0
if a > b:
  ans += a
else:
  ans += b
if c > d
  ans += c
else:
  ans += d
print(ans)
	

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())
ans = 0
if a > b:
  ans += b
else:
  ans += a
if c > d:
  ans += d
else:
  ans += c
print(ans)
Buggy code:
a = input()
b = input()
c = input()
d = input()
print(min(a,b) + min(c,d))

Fixed code:
a = int(input())
b = int(input())
c = int(input())
d = int(input())

print(min(a, b)+min(c, d))
Buggy code:
A, B, C, D=[int(input()) for i in range(4)]
if A<=B:
  train=A
else:
  train=B
if C<=D:
  bus=C
else:
  bus=D
print(A+B)

Fixed code:
A, B, C, D=[int(input()) for i in range(4)]
if A<=B:
  train=A
else:
  train=B
if C<=D:
  bus=C
else:
  bus=D
print(train+bus)
Buggy code:
import sys

input = sys.stdin.readline


def main():
    a = int(input())
    b = int(input())
    c = int(input())
    d = int(input())
    print(a if a < b else b + c if c < d else d)


if __name__ == "__main__":
    main()


Fixed code:
import sys

input = sys.stdin.readline


def main():
    a = int(input())
    b = int(input())
    c = int(input())
    d = int(input())
    print((a if a < b else b) + (c if c < d else d))


if __name__ == "__main__":
    main()
Buggy code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())
Total=0
if(A>=B):
  Total=A
else:
  Total=B
if(C>=D):
  Total=Total+C
else:
  Total=Total+D
print(Total)

Fixed code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())
Total=0
if(A>=B):
  Total=B
else:
  Total=A
if(C>=D):
  Total=Total+D
else:
  Total=Total+C
print(Total)
Buggy code:
# PROBLEM A
a, b, c, d = [int(input()) for _ in range(4)]
sol = max(a, b) + max(c, d)
print(sol)

Fixed code:
# PROBLEM A
a, b, c, d = [int(input()) for _ in range(4)]
sol = min(a, b) + min(c, d)
print(sol)
Buggy code:
ABCD = []
for i in range(4):
    ticket = int(input())
    hodai = int(input())
    ABCD.append(min(ticket, hodai))

print(sum(ABCD))


Fixed code:
ABCD = []
for i in range(2):
    ticket = int(input())
    hodai = int(input())
    ABCD.append(min(ticket, hodai))

print(sum(ABCD))
Buggy code:
train_normal = input()
train_unlimited = input()
bus_normal = input()
bus_unlimited = input()
train_normal = input()
train = min(train_normal, train_unlimited)
bus = min(bus_normal, bus_unlimited)
total = train + bus
print(total)

Fixed code:
train_normal = int(input())
train_unlimited = int(input())
bus_normal = int(input())
bus_unlimited = int(input())
train = min(train_normal, train_unlimited)
bus = min(bus_normal, bus_unlimited)
total = train + bus
print(total)
Buggy code:
A = [int(input()) for i in range(4)]
print(min(A[0]+A[1])+min(A[2]+A[3]))

Fixed code:
A = [int(input()) for i in range(4)]
print(min(A[0],A[1])+min(A[2],A[3]))
Buggy code:
a = []
for _ in range(4):
    a.append(int(input))

print(min(min(a[0],a[1]), min(a[2],a[3])))


Fixed code:
a = []
for _ in range(4):
    a.append(int(input()))

print(min(a[0],a[1])+ min(a[2],a[3]))
Buggy code:
B = int(input())
C = int(input())
D = int(input())

if A <= B:
    densya = A

else:
    densya = B

if C <= D:
    bus = C

else:
    bus = D

untin = densya + bus

print(untin)


Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

if A <= B:
    densya = A

else:
    densya = B

if C <= D:
    bus = C

else:
    bus = D

untin = densya + bus

print(untin)
Buggy code:
a = input()
b = input()
c = input()
d = input()
print(min(a,b)+min(c,d))

Fixed code:
a,b,c,d=int(input()),int(input()),int(input()),int(input())

print(min(a,b)+min(c,d))
Buggy code:
for i in range(4):
    a[i] = int(input())
print(min(a[0],a[1]) + min(a[2], a[3]))    

Fixed code:
a = [0, 0, 0, 0]
for i in range(4):
    a[i] = int(input())
print(min(a[0],a[1]) + min(a[2], a[3]))
Buggy code:
a=[0]*4
for i in range(4):
  a[i]=int(input())
print(min(a[2])+min(a[2:4]))

Fixed code:
a=[0]*4
for i in range(4):
  a[i]=int(input())
print(min(a[:2]) + min(a[2:4]))
Buggy code:
 = int(input())
b = int(input())
c = int(input())
d = int(input())
print(min(a, b) + min(c, d))


Fixed code:
a = int(input()) 
b = int(input()) 
c = int(input()) 
d = int(input()) 
print((min(a,b)+min(c,d)))
Buggy code:
def solve(string):
    a, b, c, d = map(int, string.split())
    return str(min(a, b) + min(c, d))


if __name__ == '__main__':
    n = 4
    print(solve('n'.join([input() for _ in range(n)])))


Fixed code:
def solve(string):
    a, b, c, d = map(int, string.split())
    return str(min(a, b) + min(c, d))


if __name__ == '__main__':
    n = 4
    print(solve('\n'.join([input() for _ in range(n)])))
Buggy code:
l=[int(input())for _ in range(4)]
print(min(l[0],l[1])+min(l[3],l[4]))


Fixed code:
l=[int(input())for _ in range(4)]
print(min(l[0],l[1])+min(l[2],l[3]))
Buggy code:
# | Its_Rashid | #
a = [int(input()) for i in range(4)]
print(min(a[0] , a[1] + min(a[2] , a[3])))

Fixed code:
# | Its_Rashid | #
a = [int(input()) for i in range(4)]
print(min(a[0] , a[1]) + min(a[2] , a[3]))
Buggy code:
a = [input() for i in range(4)]
print(min(a[0], a[1])+min(a[2], a[3]))


Fixed code:
a = [int(input()) for i in range(4)]
print(min(a[0], a[1])+min(a[2], a[3]))
Buggy code:
number = 4
fare = [int(input()) for a in range(number)]
 
fare_0_0 = fare[0] + fare[2] #A + C
fare_0_1 = fare[0] + fare[3] #A + D
fare_1_0 = fare[1] + fare[2] #B + C
fare_1_1 = fare[1] + fare[3] #B + D
 
fare_min = fare_0_0
if fare_min > fare_0_1:
    fare_min = fare_0_1
if fare_min > fare_1_0:
    fare_min = fare_1_0
if fare_min > fare_1_1:
  	fare_min = fare_1_1

Fixed code:
number = 4
fare = [int(input()) for a in range(number)]
 
fare_0_0 = fare[0] + fare[2] #A + C
fare_0_1 = fare[0] + fare[3] #A + D
fare_1_0 = fare[1] + fare[2] #B + C
fare_1_1 = fare[1] + fare[3] #B + D
 
fare_min = fare_0_0
if fare_min > fare_0_1:
    fare_min = fare_0_1
if fare_min > fare_1_0:
    fare_min = fare_1_0
if fare_min > fare_1_1:
    fare_min = fare_1_1
    
print(fare_min)
Buggy code:
number = 4
fare = [int(input()) for a in range(number)]

fare_train = min(fare[0:1])
fare_bus = min(fare[2:3])

print(fare_train + fare_bus)

Fixed code:
number = 4
fare = [int(input()) for a in range(number)]
 
fare_train = min(fare[0:2])
fare_bus = min(fare[2:4])
 
print(fare_train + fare_bus)
Buggy code:
a,b,c,d = [int(input()) for _ in range(4)]

print(max(a,b) + max(c,d))

Fixed code:
a,b,c,d = [int(input()) for _ in range(4)]

print(min(a,b) + min(c,d))
Buggy code:
A=input()
B=input()
C=input()
D=input()
fee=0
if A<B:
    fee=fee+A
else:
    fee=fee+B
if C<D:
    fee=fee+C
else:
    fee=fee+D

print(fee)


Fixed code:
A=int(input())
B=int(input())
C=int(input())
D=int(input())
fee=0
if A<B:
    fee=fee+A
else:
    fee=fee+B
if C<D:
    fee=fee+C
else:
    fee=fee+D

print(fee)
Buggy code:
def solver(a, b, c, d):
  """
  >>> solver(600, 300, 220, 420)
  520
  >>> solver(555, 555, 400, 200)
  755
  >>> solver(549, 817, 715, 603)
  1152
  """

  result = 0

  result += a if a < b else b
  result += c if c < d else d

  return result

if __name__ == '__main__':
  inputs = [int(input()) for _ in range(4)]
  solver(inputs[0], inputs[1], inputs[2], inputs[3])


Fixed code:
def solver(a, b, c, d):
  """
  >>> solver(600, 300, 220, 420)
  520
  >>> solver(555, 555, 400, 200)
  755
  >>> solver(549, 817, 715, 603)
  1152
  """

  result = 0

  result += a if a < b else b
  result += c if c < d else d

  return result

if __name__ == '__main__':
  inputs = [int(input()) for _ in range(4)]
  print(solver(inputs[0], inputs[1], inputs[2], inputs[3]))
Buggy code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

if( A < B):
  if(C < D):
    print(A + C)
    
  else:
    print(A + D)
    
else:
  if(C < D)
    print(B + C)
  
  else:
    print(B + D)


Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())

if( A < B):
  if(C < D):
    print(A + C)
    
  else:
    print(A + D)
    
else:
  if(C < D):
    print(B + C)
  
  else:
    print(B + D)
Buggy code:
a = []
for i in range(4):
    a.append(int(input()))
print(a)

train = min(a[0],a[1])
bus = min(a[2],a[3])

print(train + bus)

Fixed code:
a = []
for i in range(4):
    a.append(int(input()))


train = min(a[0],a[1])
bus = min(a[2],a[3])

print(train + bus)
Buggy code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())
print(min(min(A+C, A-D), min(B-C, B-D)))

Fixed code:
A = int(input())
B = int(input())
C = int(input())
D = int(input())
print(min(min(A+C, A+D), min(B+C, B+D)))
Buggy code:
l = [int(input() for i in range(4)]
print(min(l[0],l[1])+min(l[2],l[3]))


Fixed code:
l = [int(input()) for i in range(4)]
print(min(l[0],l[1])+min(l[2],l[3]))
Buggy code:
fee = []
for i in range(4):
  fee.append(int(input()))
ans += mix(fee[0], fee[1])
ans += mix(fee[2], fee[3])
print(ans)

Fixed code:
fee = []
ans = 0
for i in range(4):
  fee.append(int(input()))
ans += min(fee[0], fee[1])
ans += min(fee[2], fee[3])
print(ans)
Buggy code:
[a,b,c,d]=[input() for i in range(4)]
print(min(a,b)+min(c,d))


Fixed code:
[a,b,c,d]=[int(input()) for i in range(4)]
print(min(a,b)+min(c,d))
Buggy code:
a = map(int, input())
b = map(int, input())
c = map(int, input())
d = map(int, input())
print(min(a,b) + min(c,d))

Fixed code:
a = input()
b = input()
c = input()
d = input()
print(min(int(a),int(b)) + min(int(c),int(d)))
Buggy code:
a = input()
b = input()
c = input()
d = input()
print(min(a, b)+min(c,d))

Fixed code:
a, b, c, d = int(input()), int(input()), int(input()), int(input())
print(min(a, b) + min(c, d))