qyliang/CodeNanoFix huggingface dataset:
Buggy code:
a, b = map(string, input().split())
s = ''
if a > b:
	for _ in range(int(a)):
		s += b
else:
	for _ in range(int(b)):
		s += a
print(s)

Fixed code:
a, b = map(str, input().split())
s = ''
if a > b:
	for _ in range(int(a)):
		s += b
else:
	for _ in range(int(b)):
		s += a
print(s)
Buggy code:
import numpy as np

x = list(map(int,input().split()))
if x[0] > x[1]:
    ans = np.repeat(x[1],x[0])
    for i in ans:
        print(i, end="")
    
elif x[0] < x[1]:
    for i in ans:
        print(i, end="")
    
else:
    for i in ans:
        print(i, end="")

Fixed code:
import numpy as np

x = list(map(int,input().split()))
if x[0] > x[1]:
    ans = np.repeat(x[1],x[0])
    for i in ans:
        print(i, end="")
    
elif x[0] < x[1]:
    ans = np.repeat(x[0],x[1])
    for i in ans:
        print(i, end="")
    
else:
    ans = np.repeat(x[0],x[1])
    for i in ans:
        print(i, end="")
Buggy code:
b, c = map(int, input().split())
if b >= c:
  print(str(b) * c)
else:
  print(str(c) * b)

Fixed code:
b, c = map(int, input().split())
if b >= c:
  print(str(c) * b)
else:
  print(str(b) * c)
Buggy code:
a,b = map(str,input().split())
lst = [a*b,b*a]
new = sorted(lst)
print(new[0])

Fixed code:
a,b = map(str,input().split())
lst = [a*int(b),b*int(a)]
new = sorted(lst)
print(new[0])
Buggy code:
a = list(map(str, input().split()))

if a[0] >= a[1]:
    print(a[0] * int(a[1]))
else:
    print(a[1] * int(a[0]))

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

if a >= b:
    print(int(str(b)*a))
else:
    print(int(str(a)*b))
Buggy code:
a, b = map(int, input().split())
c = max(a, b)
d = min(a, b)
ans = str(c)*d
print(ans)

Fixed code:
a, b = map(int, input().split())
c = max(a, b)
d = min(a, b)
ans = str(d)*c
print(ans)
Buggy code:
a,b=map(int, input().split())
tex=""
if a <= b:
    for i in range(a):
        tex+=str(a)
    print(tex)
else:
    for i in range(b):
        tex+=str(b)
    print(tex)

Fixed code:
a,b=map(int, input().split())
tex=""
if a <= b:
    for i in range(b):
        tex+=str(a)
    print(tex)
else:
    for i in range(a):
        tex+=str(b)
    print(tex)
Buggy code:
a,b = map(int, input().split())

if a < b:
  print(str(a) * b)
elif b < a:
  print(str(b) * a)

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

if a < b:
  print(str(a) * b)
elif b < a:
  print(str(b) * a)
elif a == b:
  print(str(a) * b)
Buggy code:
a, b = map(int,input().split())
min_a=str(a)*b
min_b=str(b)*a
print(min(min_a, min_b)

Fixed code:
a,b = map(int,input().split())
min_a=str(a)*b
min_b=str(b)*a
print(min(min_a, min_b))
Buggy code:
a,b = input().split()
print(a*int(b) if a>b else b*int(a))

Fixed code:
a, b = input().split()
print(b * int(a) if a > b else a * int(b))
Buggy code:
[a,b] = [int(s) for s in input().rstrip().split(' ')]
W = ""
if a < b:
  for i in range(b):
    W.append(str(a))
  print(W)
else:
  for i in range(a):
    W.append(str(b))
  print(W) 
  

Fixed code:
[a,b] = [int(s) for s in input().rstrip().split(' ')]
W = ""
if a < b:
  for i in range(b):
    W += str(a)
  print(W)
else:
  for i in range(a):
    W += str(b)
  print(W)
Buggy code:
a, b = map(int, input().split())

p = ""
q = ""

for i in range(b):
    p = p + str(a)

for i in range(a):
    q += str(b)

list = [p, q]

sorted(list)
print(list[0])

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

p = ""
q = ""

for i in range(b):
    p = p + str(a)

for i in range(a):
    q += str(b)

lst = [p, q]

lst = sorted(lst)

print(lst[0])
Buggy code:
a,b=map(int,input().split())
if str(a)*b>str(b)*a:
  print(str(a)*b)
else:
  print(str(b)*a)


Fixed code:
a, b = map(int, input().split())
if a == b:
    print(str(a) * a)
elif a > b:
    print(str(b) * a)
else:
    print(str(a) * b)
Buggy code:
a,b = map(int,input().split())
print(str(min(a,b)*max(a,b))

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

A = [a]*b
B = [b]*a

AA = int("".join(map(str, A)))
BB = int("".join(map(str, B)))

if AA >= BB:
    print(BB)
else:
    print(AA)

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

A = [a]*b
B = [b]*a

AA = int("".join(map(str, A)))
BB = int("".join(map(str, B)))

if A >= B:
    print(BB)
else:
    print(AA)
Buggy code:
def main():
    a, b = input().split()
    A = a*int(a)
    B = b*int(b)
    ans = sorted([A, B])
    print(ans[0])


if __name__ == "__main__":
    main()

Fixed code:
def main():
    a, b = input().split()
    A = a*int(b)
    B = b*int(a)
    ans = sorted([A, B])
    print(ans[0])


if __name__ == "__main__":
    main()
Buggy code:
A,B = map(int, input().split())
Ans = ''

if A <= B:
  for i in range(A):
    Ans = Ans + str(B)

else:
  for j in range(B):
    Ans = Ans + str(A)

print(Ans)

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

if A <= B:
  for i in range(B):
    Ans = Ans + str(A)

else:
  for j in range(A):
    Ans = Ans + str(B)

print(Ans)
Buggy code:
a, b = map(int, input().split())
if a < b:
  print(a * int(b))
else:
  print(b * int(a))

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

if a < b:
    print(str(a)*b)
else:
    print(str(b)*a)
Buggy code:
a, b = map(int, input().split())

A = [str(a)]*b
B = [str(b)]*a

A = int("".join(A))
B = int("".join(B))

if A<=B:
  print(A)
else:
  print(B)

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

A = [str(a)]*b
B = [str(b)]*a

A = int("".join(A))
B = int("".join(B))

if a <= b:
  print(A)
else:
  print(B)
Buggy code:
num = list(map(int, input().split()))

if num[0] == num[1]:
  max = num[0]
  min = num[1]
else:
  max = max(num[0],num[1])
  min = min(num[0],num[1])
  
print(str(max)*min)

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

if num[0] == num[1]:
  max = num[0]
  min = num[1]
else:
  max = max(num[0],num[1])
  min = min(num[0],num[1])
  
print(str(min)*max)
Buggy code:
# B
a, b = map(int, input().split())

a2 = int(str(a)*b)
b2 = int(str(b)*a)

if a2<b2:
  print(a2)
else:
  print(b2)

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

a2 = str(a)*b
b2 = str(b)*a

if a<b:
  print(a2)
else:
  print(b2)
Buggy code:
a,b=map(int,input().split())
hai1=[]
hai2=[]
for k in range(0,a):
  hai1.append(str(b))
for i in range(0,b):
  hai2.append(str(a))
ak="".join(hai1)
bk="".join(hai2)
c=[0]*2
c[0]=int(ak)
c[1]=int(bk)
c.sort()
print(c[0])

Fixed code:
a,b=map(int,input().split())
hai1=[]
hai2=[]
for k in range(0,a):
  hai1.append(str(b))
for i in range(0,b):
  hai2.append(str(a))
ak="".join(hai1)
bk="".join(hai2)
c=[0]*2
c[0]=ak
c[1]=bk
c.sort()
print(int(c[0]))
Buggy code:
a,b = map(int, input().split())

for i in range(max(a,b)):
  print(min(a,b))


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

for i in range(max(a,b)):
  print(min(a,b), end="")
Buggy code:
a,b=map(int,input().split())
if a>b:
  print(str(a)*b)
elif a<b:
  print(str(b)*a)
else:
  print(str(a)*b)

Fixed code:
a,b=map(int,input().split())
if a>b:
  print(int(str(b)*a))
elif a<b:
  print(int(str(a)*b))
else:
  print(int(str(a)*b))
Buggy code:
a, b = (int(x) for x in input().split())
aa = str(a) * a
bb = str(b) * b
if aa > bb:
    print(aa)
else:
    print(bb)

Fixed code:
a, b = (int(x) for x in input().split())
aa = str(a) * b
bb = str(b) * a
if aa < bb:
    print(aa)
else:
    print(bb)
Buggy code:
a, b = map(int, input().split())

ab = ''
ba = ''

for i in range(b):
    ab += str(b)

for i in range(a):
    ba += str(a)

if ab <= ba:
    print (ab)
else:
    print (ba)

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

ab = ''
ba = ''

for i in range(a):
    ab += str(b)

for i in range(b):
    ba += str(a)

if ab <= ba:
    print (ab)
else:
    print (ba)
Buggy code:
a, b = map(int, input().split())

if(a >= b):
    print(str(a) * b)
else:
    print(str(b) * a)


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

if a>=b:
       print(str(b)*a)
else:
       print(str(a)*b)
Buggy code:
a, b = input().split()
aa = ""
bb = ""
for i in range(1, int(b)):
    aa += a
for j in range(1, int(a)):
    bb += b

if (a>b):
    print(bb)
else:
    print(aa)

Fixed code:
a, b = input().split()
aa = ""
bb = ""
for i in range(0, int(b)):
    aa += a
for j in range(0, int(a)):
    bb += b

if (int(a)>int(b)):
    print(bb)
else:
    print(aa)
Buggy code:
a,b=map(int,input().split())
ans=""
if a>=b:
    for i in range(b):
        ans+=str(a)
else:
    for i in range(a):
        ans+=str(b)
print(ans)

Fixed code:
a,b=map(int,input().split())
ans=""
if a>=b:
    for i in range(a):
        ans+=str(b)
else:
    for i in range(b):
        ans+=str(a)
print(ans)
Buggy code:
a,b = map(int, input().split())
if a > b:
  print(str(a)*b)
else:
  print(str(b)*a)

Fixed code:
a,b = map(int, input().split())
if a > b:
  print(str(b)*a)
else:
  print(str(a)*b)
Buggy code:
a, b = map(int, input().split())
print(str(a)*b if a>=b else str(b)*a)

Fixed code:
a,b = map(int, input().split())
if a>=b:
    print(str(b)*a)
else:
    print(str(a)*b)
Buggy code:
a, b = input().split()
if a < b:
    print(b * int(a))
elif a > b:
    print(a * int(b))
else:
    print(a * int(a))

Fixed code:
a, b = input().split()
if a < b:
    print(a * int(b))
elif a > b:
    print(b * int(a))
else:
    print(a * int(a))
Buggy code:
a,b = map(int, input().split())
if a < b:
  print(str(a**b))
else:
  print(str(b**a))

Fixed code:
a,b = map(int, input().split())
if a < b:
  print(str(a) * b)
else:
  print(str(b) * a)
Buggy code:
a,b = map(int,input().split())
if a<b:
  min = a
  max = b
else:
  min = b
  max = a
c =[min for i in range(max)]
l = "".join(c)
print(l)

Fixed code:
a,b = map(int,input().split())
if a<b:
  min = a
  max = b
else:
  min = b
  max = a
c =[min for i in range(max)]
d = map(str,c)
l = "".join(d)
print(l)
Buggy code:
a,b  =map(int,input().split())
if a >= b:
  print(str(a) * b)
else:
  print(str(b) * a)

Fixed code:
a,b  =map(int,input().split())
if a >= b:
  print(str(b) * a)
else:
  print(str(a) * b)
Buggy code:
input_ab = input().split(' ')
a = int(input_ab[0])
b = int(input_ab[1])

ab = ""
ba = ""

for i in range(b+1):
  ab = ab + input_ab[0]

for i in range(a+1):
  ba = ba + input_ab[1]

dic = [ab, ba]
sdic = sorted(dic)

print(sdic[0])


Fixed code:
input_ab = input().split(' ')
a = int(input_ab[0])
b = int(input_ab[1])

ab = ""
ba = ""

for i in range(b):
  ab = ab + input_ab[0]

for i in range(a):
  ba = ba + input_ab[1]

dic = [ab, ba]
sdic = sorted(dic)

print(sdic[0])
Buggy code:
a,b = map(int,input().split())

if a <= b:
	for i in range(b):
		print("a",end = "")


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


if a>b :
    a,b=b,a

for i in range(b):
    print(a,end="")
Buggy code:
a, b = map(int, input().split())
ss = []
ss.append(str(a) * b)
ss.append(str(b) * a)
print(sorted(ss))


Fixed code:
a, b = map(int, input().split())
ss = []
ss.append(str(a) * b)
ss.append(str(b) * a)
print(sorted(ss)[0])
Buggy code:
def func():
    return

# n = int(input())
# s = input()
a, b = map(int, input().split())
# a = list(map(int, input().split()))
# a = input().split()

ans = ""
if a <= b:
    for i in b:
        ans += str(a)
else:
    for j in a:
        ans += str(b)

print(ans)



Fixed code:
def func():
    return

# n = int(input())
# s = input()
a, b = map(int, input().split())
# a = list(map(int, input().split()))
# a = input().split()

ans = ""
if a <= b:
    for i in range(b):
        ans += str(a)
else:
    for j in range(a):
        ans += str(b)

print(ans)
Buggy code:
a, b = map(int,input().split())
if a >= b:
  a = str(a)a
  print(a*b)
else:
  b = str(b)
  print(b*a)

Fixed code:
a, b = map(int,input().split())
if b >= a:
  a = str(a)
  print(a*b)
else:
  b = str(b)
  print(b*a)
Buggy code:
a,b = map(str, input().split())

lis = []
res_a = a
res_b = b

for i in range(int(b)-1):
  res_a += a
lis.append(res_a)

for i in range(int(a)-1):
  res_b += b
lis.append(res_b)

print(int(sorted(lis)[0][0]))
  

Fixed code:
a,b = map(str, input().split())
 
lis = []
res_a = a
res_b = b
 
for i in range(int(b)-1):
  res_a += a
lis.append(res_a)
 
for i in range(int(a)-1):
  res_b += b
lis.append(res_b)
 
print(int(sorted(lis)[0]))
Buggy code:
a, b= map(int,input().split())

if a < b:
    print(str(a)*b)
elif b > a:
    print(str(b)*a)
else:
    print(str(a)*b)


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

if a < b:
    print(str(a)*b)
elif a > b:
    print(str(b)*a)
else:
    print(str(a)*b)
Buggy code:
a,b=map(int,input().split())
a_string=a*int(b)
b_string=b*int(a)
answer=sorted([a_string,b_string])
print(answer[0])

Fixed code:
a,b=input().split()
a_string=a*int(b)
b_string=b*int(a)
answer=sorted([a_string,b_string])
print(answer[0])
Buggy code:
a,b = list(map(int, input().split()))
c = [a,b]
c.sort()
ans = "".join(str(c[0])*c[0])
print(ans)

Fixed code:
a,b = list(map(int, input().split()))
c = [a,b]
c.sort()
ans = "".join(str(c[0])*c[1])
print(ans)
Buggy code:
a, b = map(int, input().split())

s1 = "a" *b
s2 = "b" *a
if s1 < s2:
    print(s1)
else:
    print(s2)

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

s1 = str(a) *b
s2 = str(b) *a
if s1 < s2:
    print(s1)
else:
    print(s2)
Buggy code:
a,b = input().split()
print(a*int(b))if a<b else b*int(a)

Fixed code:
a,b = input().split()
print(a*int(b)if a<b else b*int(a))
Buggy code:
a, b = map(int, input().split())
print(str(max(a,b))*min(a,b))

Fixed code:
a,b = map(int,input().split())
ans = str(min(a,b))*max(a,b)
print(ans)
Buggy code:
a, b = map(int, input().split())

A = ''.join([str(a)] * a)
B = ''.join([str(b)] * b)

if A <= B:
    print(A)
else:
    print(B)

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

A = ''.join([str(a)] * b)
B = ''.join([str(b)] * a)

if A <= B:
    print(A)
else:
    print(B)
Buggy code:
a,b = input().split()
A = a*int(b)
B = b*int(a)

if A > B:
    print(A)
elif A < B:
    print(B)
else:
    print(A)

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

if A > B:
    print(B)
elif A < B:
    print(A)
else:
    print(A)
Buggy code:
a, b = map(int, input().split())
print(a*int(b) if a*int(b) <= b*int(a) else b*int(a))

Fixed code:
a, b = map(int, input().split())
print(str(a) * int(b) if a < b else str(b) * int(a))
Buggy code:
a, b = list(map(int, input().split()))

ab = str(str(a) * b)
ba = str(str(b) * a)

print(sorted([ab, ba]))
print(sorted([ab, ba])[0])


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

ab = str(str(a) * b)
ba = str(str(b) * a)

print(sorted([ab, ba])[0])
Buggy code:
a,b = map(int,input().split())
if a >= b:
  print(b*int(a))
else:
  print(a*int(b))

Fixed code:
a,b = map(str,input().split())
if a >= b:
  print(b*int(a))
else:
  print(a*int(b))
Buggy code:
a,b=map(int,input().split())
A=str(a)
B=str(b)
num_1=int(A*b)
num_2=int(B*a)
if num_1>=num_2:
  print(num_2)
elif num_1<num_2:
  print(num_1)


Fixed code:
a,b=map(int,input().split())
A=str(a)
B=str(b)
num_1=int(A*b)
num_2=int(B*a)
if num_1>num_2:
  print(num_1)
elif num_1<num_2:
  print(num_2)
elif num_1==num_2:
  print(num_1)
Buggy code:
a,b = list(input().split())
print(min(a*int(b), b*int(a))

Fixed code:
a,b = list(input().split())
print(min(a*int(b), b*int(a)))
Buggy code:
a,b=map(str,input().split())
res = ""
if a < b:
  for i in range(b):
    res += a
else:
  for i in range(a):
  res += b
print(res)

Fixed code:
a,b=map(str,input().split())
res = ""
if a < b:
  for i in range(int(b)):
    res += a
else:
  for i in range(int(a)):
    res += b
print(res)
Buggy code:
a, b = map(int, input().split())
c = ''
if a >= b:
  for i in range(b):
    c += str(a)
else:
  for i in range(a):
    c += str(b)
    
print(c)
    


Fixed code:
a, b = map(int, input().split())
c = ''
if a >= b:
  for i in range(a):
    c += str(b)
else:
  for i in range(b):
    c += str(a)
    
print(int(c))
Buggy code:
a,b=input().split()
A=int(a)
B=int(b)
aa=a
bb=b
for i in range(B-1):
    aa+=a
for j in range(A-1):
    bb+=b
if int(aa) >= int(bb):
    print(bb)
else:
    print(aa)

Fixed code:
a,b=input().split()
A=int(a)
B=int(b)
aa=a
bb=b
for i in range(B-1):
    aa+=a
for j in range(A-1):
    bb+=b
if aa >= bb:
    print(bb)
else:
    print(aa)
Buggy code:
a,b=map(int,input().split())
if a<=b:
    print(str(a)*a)
else:
    print(str(b)*b)

Fixed code:
a, b = map(int, input().split(' '))
if a < b:
    print(str(a)*b)
else:
    print(str(b)*a)
Buggy code:
n,m = map(int,input().split())

for _ in range(m):
    a += str(n)
for _ in range(n):
    b += str(m)

print(a if n <= m else b)

Fixed code:
n,m = map(int,input().split())
a = b = ''
for _ in range(m):
    a += str(n)
for _ in range(n):
    b += str(m)

print(a if n <= m else b)
Buggy code:
a,b=map(int,input().split())
a_=a*b
b_=b*a
s=[a_,b_]
s.sort()
print(s[0])

Fixed code:
a,b=map(int,input().split())
a_=str(a)*b
b_=str(b)*a
s=[a_,b_]
s.sort()
print(s[0])
Buggy code:


a, b = input().split()

int_a = int(a)
int_b = int(b)

a_List = ''
b_List = ''

for i in range(int_a):
    b_List = b_List + b

for i in range(int_b):
    a_List = a_List + a


print('a_List : ' + a_List)
print('b_List : ' + b_List)

# a_List = int(a_List)
# b_List = int(b_List)


if a_List => b_List:
    print(a_List)

else:
    print(b_List)

Fixed code:

a, b = input().split()

int_a = int(a)
int_b = int(b)

a_List = ''
b_List = ''

for i in range(int_a):
    b_List = b_List + b

for i in range(int_b):
    a_List = a_List + a


# print('a_List : ' + a_List)
# print('b_List : ' + b_List)

a_List = int(a_List)
b_List = int(b_List)

if a_List >= b_List:
    print(a_List)

else:
    print(b_List)
Buggy code:
M, N = map(int, input().split())

if M > N:
  body = N
  numm = M
else:
  body = M
  numm = N

ret = ''
for i in numm:
  ret += str(body)
print(ret)

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

if M > N:
  body = N
  numm = M
else:
  body = M
  numm = N

ret = ''
for i in range(numm):
  ret += str(body)
print(ret)
Buggy code:
a,b = map(int,input().split())
if a>b:
  print(str(b)*a)
 else:
  print(str(a)*b)

Fixed code:
a,b = map(int, input().split())
if a>b:
    print(str(b)*a)
else:
    print(str(a)*b)
Buggy code:
get = map(int, input().split())
a = get[0]
b = get[1]
if a <= b:
  print(str(a) * b)
elif a > b:
  print(str(b) * a)

Fixed code:
get = list(map(int, input().split()))
a = get[0]
b = get[1]
if a <= b:
  print(str(a) * b)
elif a > b:
  print(str(b) * a)
Buggy code:
a=input().split(" ")
x1=""
x2=""

for j in range(int(a[0])):
    x1=x1+a[0]

for y in range(int(a[1])):
    x2=x2+a[1]

z1=int(x1)
z2=int(x2)

if x1>x2:
	print(x1)
elif x1<x2:
	print(x2)
else:
	print(x1)







Fixed code:
a=input().split(" ")
x1=""
x2=""

for j in range(int(a[0])):
    x1=x1+a[1]

for y in range(int(a[1])):
    x2=x2+a[0]

z1=int(x1)
z2=int(x2)

if x1<x2:
	print(x1)
elif x1>x2:
	print(x2)
else:
	print(x1)
Buggy code:
a,b = (int(x) for x in input().split())
if a > b:
  print(b * a)
else:
  print(a * b)
  

Fixed code:
a,b=(int(x) for x in input().split())
if a>b:
  print(str(b)*a)
else:
  print(str(a)*b)
Buggy code:
a,b=map(int,input().split())
c=str("a")*b
d=str("b")*a
if a>=b:
    print(d)
else:
    print(c)


Fixed code:
a,b=map(int,input().split())
c=str(a)*b
d=str(b)*a
if a>=b:
    print(d)
else:
    print(c)
Buggy code:
l=list(map(int,input().split()));print(min(l)*max(l))

Fixed code:
l=list(map(int,input().split()));print(str(min(l))*max(l))
Buggy code:
a , b =map(int,input().split())
#print(a,b)

if a < b :
    print(a*b)
else :
    print(b*a)

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

if a < b :
    print(str(a)*b)
else :
    print(str(b)*a)
Buggy code:
a , b =map(int,input().split())
#print(a,b)

if a < b :
    print(a*str(b))
else :
    print(b*str(a))

Fixed code:
a,b = map(int,input().split())
if a <= b:
    print(str(a)*b)
else:
    print(str(b)*a)
Buggy code:
a,b=map(int,input().split())
x=int(str(a)*b)
y=int(str(b)*a)
print(min(x,y))

Fixed code:
a,b=map(int, input().split())
x=str(a)*b
y=str(b)*a
print(min(x,y))
Buggy code:
a, b = map(int, input().split())

if a >= b:
  for i in range(a): print(b)
else:
  for i in range(b): print(a)

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

if a >= b:
  for i in range(a): print(b, end="")
else:
  for i in range(b): print(a, end="")
Buggy code:
N,M = input().split()

J = int(N)
K = int(M)

if N > M:
  print(M*K)
else:
  print(N*J)

Fixed code:
N,M = input().split()

J = int(N)
K = int(M)

if N > M:
  print(M*J)
else:
  print(N*K)
Buggy code:
Input = input().split()
Input[0] = int(Input[0])
Input[1] + int(Input[1])

if Input[0] >= Input[1]:
  print(str(Input[1])*Input[0])

else:
  print(str(Input[0])*Input[1])

Fixed code:
Input = input().split()
Input[0] = int(Input[0])
Input[1] = int(Input[1])
 
if Input[0] >= Input[1]:
  print(str(Input[1])*Input[0])
  
else:
  print(str(Input[0])*Input[1])
Buggy code:
a, b = input().split()
l = [str(a) * int(b), str(b) * int(a)].sort()
print(l[0])

Fixed code:
a, b = input().split()
l = [str(a) * int(b), str(b) * int(a)]
l.sort()
print(l[0])
Buggy code:
def execute(key: int, base: str) -> str:
  s = ""
  for i in range(key):
    s += str(base)
  return s

a, b = input().split()
c = [execute(a, b), execute(b, a)]
print(sorted(c)[0])

Fixed code:
def execute(key: int, base: str) -> str:
  s = ""
  for i in range(key):
    s += str(base)
  return s

a, b = input().split()
c = [execute(int(a), b), execute(int(b), a)]
print(sorted(c)[0])
Buggy code:
a,b = map(int,input().split())
s = ''
if a> b:
    for i in range(len(b)):
        s = s+str(a)
else:
    for i in range(len(a)):
        s = s+str(b)
print(s)

Fixed code:
a,b = map(int,input().split())
s = ''
if a> b:
    for i in range(a):
        s = s+str(b)
else:
    for i in range(b):
        s = s+str(a)
print(s)
Buggy code:
a, b = input().split()

aa = str(a*int(b))
bb = str(b*int(a))

aa = str(1000)
bb = str(111)

if aa <= bb:
  print(aa)
else:
  print(bb)

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

aa = str(a*int(b))
bb = str(b*int(a))

if aa <= bb:
  print(aa)
else:
  print(bb)
Buggy code:
a, b = map(int, input().split())
if(a>=b):
  print(str(a) * b)
else:
  print(str(b)*a)

Fixed code:
a,b = map(int,input().split())
if a>b:
    print(str(b)*a)
elif b>a:
    print(str(a)*b)
else:
    print(str(a)*a)
Buggy code:
a, b = map(int, input().split())
ans = ""

if a < b:
  for i in range(b):
    ans += str(a)
elif b < a:
  for i in range(a):
    ans += str(b)

print(ans)

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

if a <= b:
  for i in range(b):
    ans += str(a)
elif b < a:
  for i in range(a):
    ans += str(b)

print(ans)
Buggy code:
A, B = map(int, input().split())

print(min(int(str(A)*B), int(str(B)*A)))

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

print(min(str(A)*B, str(B)*A))
Buggy code:
a,b=map(int, input().split())
A=str(a);B=str(b);
if a>=b:
    print(A*b)
else :
    print(B*a)

Fixed code:
a,b=map(int, input().split())
A=str(a);B=str(b);
if a<=b:
    print(A*b)
else :
    print(B*a)
Buggy code:
M = input().split()
i = 0
a = ''
b = ''
c = [0,0]
for i in range(int(M[0])):
    a += str(M[1])
for i in range(int(M[1])):
    b += str(M[0])
c[0] = int(a)
c[1] = int(b)  
c.sort()
print(c[0])

Fixed code:
M = input().split()
i = 0
a = ''
b = ''
c = [0,0]
for i in range(int(M[0])):
    a += str(M[1])
for i in range(int(M[1])):
    b += str(M[0])
c[0] = int(a)
c[1] = int(b)  
c.sort()
print(str(c[1]))
Buggy code:
a,b = (int(x) for x in input().split())
if a>b:
	x = a
	a = b
	b = x
print("a"*b)

Fixed code:
a,b = (int(x) for x in input().split())
if a>b:
	x = a
	a = b
	b = x
print("%d"%a*b)
Buggy code:

a, b = map(str, input().split())

A = int(a * int(b))
B = int(b * int(a))

if A > B:
  print(A)
else:
  print(B)
  
print(B)

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

A = int(a*(int(b)))
B = int(b*(int(a)))

if A <= B:
  print(B)
else:
  print(A)
Buggy code:
a,b=map(int,input().split())

if a>=b:

    print(str(a)*b)
else:
    print(str(b)*a)


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

if a>=b:

    print(str(b)*a)
else:
    print(str(a)*b)
Buggy code:
a, b = map(str, input().split())

A = int(a * int(b))
B = int(b + int(a))

if A > B:
  print(A)
else:
  print(B)

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

A = int(a * int(b))
B = int(b * int(a))

if A > B:
  print(A)
else:
  print(B)
Buggy code:
n = min[int(i) for in in input().split()]
print(str(n)*int(n))

Fixed code:
n = [int(i) for i in input().split()]
print(str(min(n)) * max(n))
Buggy code:
a,b = map(int, input().split())
s_1 = str(a)*b
s_2 = str(b)*a

print(_1 if s_1<=s_2 else s_2)

Fixed code:
a,b = map(int, input().split())
s_1 = str(a)*b
s_2 = str(b)*a

print(s_1 if s_1<=s_2 else s_2)