qyliang/CodeNanoFix huggingface dataset:
Buggy code:
import sys


def solve(inp):
    (a, b) = inp.readline().strip().split(' ')

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

    return str(max(ab, ba))


def main():
    result = solve(sys.stdin)
    if result:
        print(result)


if __name__ == '__main__':
    main()


Fixed code:
import sys


def solve(inp):
    (a, b) = inp.readline().strip().split(' ')

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

    return str(min(ab, ba))


def main():
    result = solve(sys.stdin)
    if result:
        print(result)


if __name__ == '__main__':
    main()
Buggy code:
A,B=map(int,input().split())
if B < A:
  A,B=B,A
for i in range B;
 print(A, end="")
print()

Fixed code:
A,B=map(int,input().split())
if B < A:
  A,B=B,A
for i in range(B):
 print(A, end="")
print()
Buggy code:
a,b = int(input().split())
if "a" * b > "b" * a:
    print("b" * a)
else:
    print("a" * b)

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

a1 = str(a)
b1 = str(b)

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

if a1 < b1:
    print(a1)
else:
    print(b1)

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

a1 = ''
b1 = ''

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

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

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

if a < b:
    print(a)
else:
    print(b)
# p = list(map(int,input().split()))

# count = 0
# val = sum(p[0:k])
# val_lis = [val]
# mx_val = val
# index = 0
# mx_index = 0
# for i,j in enumerate(p[k:]):
#     val = val - p[index] + j
#     val_lis.append(val)
#     index +=1
#     if val > mx_val:
#         mx_index = index
#         mx_val = val 
    
# ans = 0
# for i in range(k):
#     ans += ((p[mx_index + i]+1.0)*(p[mx_index+i]))/ (p[mx_index+i] *2.0)
# print(ans)  




# h = sorted(h,reverse = True)
# print(sum(h[k:]))

# s,t= map(str, input().split())
# a,b= map(int, input().split())
# u = input()
# print("x"*len(u))

# if(u == s):
#     print(a-1,b)
# else:
#     print(a,b-1)


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

# count = 0
# val = sum(p[0:k])
# val_lis = [val]
# mx_val = val
# index = 0
# mx_index = 0
# for i,j in enumerate(p[k:]):
#     val = val - p[index] + j
#     val_lis.append(val)
#     index +=1
#     if val > mx_val:
#         mx_index = index
#         mx_val = val 
    
# ans = 0
# for i in range(k):
#     ans += ((p[mx_index + i]+1.0)*(p[mx_index+i]))/ (p[mx_index+i] *2.0)
# print(ans)  




# h = sorted(h,reverse = True)
# print(sum(h[k:]))

# s,t= map(str, input().split())
# a,b= map(int, input().split())
# u = input()
# print("x"*len(u))

# if(u == s):
#     print(a-1,b)
# else:
#     print(a,b-1)
Buggy code:
input_line=input().rstrip().slpit()
num1 = int(input_line[0])
num2 = int(input_line[1])

if (num1 > num2):
  print(str(num2)*num1)
elif (num1 < num2):
  print(str(num1)*num2)
elif (num1 == num2):
  print(str(num1)*num2)

Fixed code:
input_line=input().rstrip().split()
num1 = int(input_line[0])
num2 = int(input_line[1])
 
if (num1 > num2):
  print(str(num2)*num1)
elif (num1 < num2):
  print(str(num1)*num2)
elif (num1 == num2):
  print(str(num1)*num2)
Buggy code:
a,b = input().split()
ab=''
ba=''
for i in range(int(b)):
  ab += a
for i in range(int(a)):
  ba += b
l = [ab,ba]
sorted(l)
print(l[0])

Fixed code:
a,b = input().split()
ab=''
ba=''
for i in range(int(b)):
  ab += a
for i in range(int(a)):
  ba += b
l = [ab,ba]
ll = sorted(l)
print(ll[0])
Buggy code:
a,b = map(input().split())
num_a = int(a)
num_b = int(b)

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

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

if num_a < num_b:
  print(a*num_b)
else:
  print(b*num_a)
Buggy code:
s_list = list(map(int, input().split()))
final_list = [(int(str(s_list[0]) * s_list[1]))]
final_list.append(int(str(s_list[1]) * s_list[0]))
final_list.sort()
print(final_list[0])


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

final_list = [(str(s_list[0]) * s_list[1])]
final_list.append(str(s_list[1]) * s_list[0])
final_list.sort()
print(final_list[0])
Buggy code:
a,b = map(int,input().split())
if a>b:
  print(str(b)*a)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:
a, b = map(int, input().split())

s1 = ''
s2 = ''

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

for i in range(b):
  s2 += str(b)
  
if a < b:
  print(s1)
else:
  print(s2)

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

s1 = ''
s2 = ''

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

for i in range(a):
  s2 += str(b)
  
if a < b:
  print(s1)
else:
  print(s2)
Buggy code:
import numpy as np

a, b = input().split()

s = []
s.append(a*int(b))
s.append(b*int(a))

s = np.sort(s)

print(s)

Fixed code:
import numpy as np
 
a, b = input().split()
 
s = []
s.append(a*int(b))
s.append(b*int(a))
 
s = np.sort(s)
 
print(s[0])
Buggy code:
a, b = map(int, input().split())
a= min(a,b)
b= max(a,b)

print(str(a)*b)

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

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

print(ans)

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())
A=str(a)*b
B=str(b)*a
if len(A)>len(B):
  print(B)
elif len(B)>len(A):
  print(A)
else:
  for i in range(len(A)):
    if int(A[i])>int(B[i]):
      print(B)
    elif int(A[i])<int(B[i]):
      print(A)
    if i==len(A)-1:
      print(A)

Fixed code:
a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
for i in range(min(len(A),len(B))):
  if int(A[i])>int(B[i]):
    print(B)
    break
  elif int(A[i])<int(B[i]):
    print(A)
    break
  if i==min(len(A),len(B))-1:
    print(A)
Buggy code:
a, b=map(str, input().split())
if int(a)<int(b):
	c=a
    a=b
    b=c
print(b*int(a))

Fixed code:
a, b=map(str, input().split())
if int(a)<int(b):
	c=a
	a=b
	b=c
print(b*int(a))
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(str(min(a,b)) * max(a,b))
Buggy code:
a, b = input().split()
a_w = a * int(b)
b_w = b * int(a)

if a => b:
  print(b_w)
else:
  print(a_w)

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

if a > b:
  print(b_w)
else:
  print(a_w)
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())
A=str(a)*b
B=str(b)*a
l=[A,B]
print(l)
l.sort()
print(l)

Fixed code:
a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
l=[A,B]

l.sort()

print(l[0])
Buggy code:
N,M = input().split(" ")
if N > M:
  
    str = str(M)
    print(str*N)

else:
    str = str(N)
    print(str*M)




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


a_s = ""
b_s = ""

for _ in range(a):
    a_s = a_s + str(a)

for _ in range(b):
    b_s = b_s + str(b)

if a_s <= b_s:
    print(a_s)
else:
    print(b_s)


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


a_s = ""
b_s = ""

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

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

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

Fixed code:
a,b = input().split()
if a > b:
    print(b * int(a))
else:
    print(a * int(b))
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(b)*a)
elif b<a:
  print(str(a)*b)
else:
  print(str(a)*b)
Buggy code:
n,m=[int(i) for i in input().split()]
ans=""
if n>=m:
  for i in range(n):
    ans+=m
else:
  for i in range(m):
    ans+=n
print(ans)

Fixed code:
n,m=[int(i) for i in input().split()]
ans=""
if n>=m:
  for i in range(n):
    ans+=str(m)
else:
  for i in range(m):
    ans+=str(n)
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 = input().split()

l = a ** int(b)
r = b ** int(a)

l = int(l)
r = int(r)

if l > r:
    print(l)
else
    print(r)

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

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

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

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

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

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


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

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

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

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

a = data[0]
b = data[1]

ans = min(a, b) * max(a, b)

print(ans)


Fixed code:
data = input().split()
 
a = data[0]
b = data[1]
 
ans = min(a, b) * int(max(a, b))
 
print(ans)
Buggy code:
a,b=input().split()
print(min(int(b*int(a)),int(a*int(b))))

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

print(a*int(b) if "a"*int(b) <= "b"*int(a) else "b"*int(a))


Fixed code:

a, b = input().split()
print(a*int(b) if a<b else b*int(a))
Buggy code:
def repeat_string(x, y):
    """Return the digit x repeated y times."""
    single_string = str(x)
    repeat_string = single_string*y
    return repeat_string


def compare_strings(a, b):
    if a>b: return(repeat_string(b, a))
    return(repeat_string(a, b))


if __name__ == "__main__":
    test1 = "4 3"
    test2 = "7 7"
    test = test2
    test_input = map(int, intput().split())
    print(compare_strings(*test_input))


Fixed code:
def repeat_string(x, y):
    """Return the digit x repeated y times."""
    single_string = str(x)
    repeat_string = single_string*y
    return repeat_string


def compare_strings(a, b):
    if a>b: return(repeat_string(b, a))
    return(repeat_string(a, b))


if __name__ == "__main__":
    test1 = "4 3"
    test2 = "7 7"
    test = test2
    test_input = map(int, input().split())
    print(compare_strings(*test_input))
Buggy code:
O,K = input().split()
I = O*int(k)
U = K*int(O)
print(sorted([I,U])[0])

Fixed code:
O,K = input().split()
I = O*int(K)
U = K*int(O)
print(sorted([I,U])[0])
Buggy code:
a,b=map(int, input().split())
ans = ""
for i in range(max([a,b])):
  ans = ans + min([a,b])
print(ans)

Fixed code:
a,b=map(int, input().split())
ans = ""
for i in range(max([a,b])):
  ans = ans + str(min([a,b]))
print(ans)
Buggy code:
num=[int(e) for e in input().split()]
A=str(num[0])
B=str(num[1])
if num[0]>=num[1]:
  for i in range(num[0]-1):
    B+=str(num[1])
  print(B)
else:
  for i in range(num[1]-1):
	A+=str(num[0])
  print(A)

Fixed code:
num=[int(e) for e in input().split()]
A=str(num[0])
B = str(num[1])

if num[0]>=num[1]:
  for i in range(num[0]-1):
    B+=str(num[1])
  print(B)
else:
  for i in range(num[1]-1):
      A+=str(num[0])
  print(A)
Buggy code:
a,b=map(str,input().split())
ab:str=""
ba:str=""
for i in range(int(a)):
    ab+=b
for i in range(int(b)):
    ba+=a
#print(ab)
#print(ba)
if(int(ab)>int(ba)):
    print(int(ba))
elif(int(ab)==int(ba)):
    print(int(ab))
else:
    print(int(ab))

Fixed code:
a,b=map(str,input().split())
ab=""
ba=""
for i in range(int(a)):
    ab+=b
for i in range(int(b)):
    ba+=a
#print(ab)
#print(ba)
if(ab>ba):
    print(int(ba))
elif(ab==ba):
    print(int(ab))
else:
    print(int(ab))
Buggy code:
a,b = map(str,input().split())
c=a*int(b)
d=b*int(b)
print(min(c,d))

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


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

print(str(max(N,M)) * min(N,M))

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

print(str(min(N,M)) * max(N,M))
Buggy code:
a, b = map(int, input().split())
A = int(str(a)**b)
B = int(str(b)**a)

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

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

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

Fixed code:
a, b = map(int, input().split())
if a>b:
    b=str(b)
    print(b*a)
else:
    a=str(a)
    print(a*b)
Buggy code:
a,b=map(int,input().split())
print(str(max(a,b))*(min(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=[str(a)*b]
B=[str(b)*a]
if a>b:
    print(B)
if a<b:
    print(A)
if a==b:
    print(A)

Fixed code:
a,b=map(int,input().split())
A=[str(a)*b]
B=[str(b)*a]
if a>b:
    print(int(''.join(B)))
if a<b:
    print(int(''.join(A)))
if a==b:
    print(int(''.join(A)))
Buggy code:
a = sorted(input().split())
print(a[0] * a[1]

Fixed code:
a = sorted(input().split())
print(a[0] * int(a[1]))
Buggy code:
A,B=map(int,input().split())

a="";b=""
a=str(A)*B;b=str(B)*A
if A=<B:
    print(a)
elif A>B:
    print(b)

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

a="";b=""
a=str(A)*B;b=str(B)*A
if A<=B:
    print(a)
elif A>B:
    print(b)
Buggy code:
a,b = map(int,input().split())
numlist = []
if a > b:
  for i in range(a):
    numlist.append(str(a))
else:
  for i in range(b):
    numlist.append(str(b))
print("".join(numlist))

Fixed code:
a,b = map(int,input().split())
numlist = []
if b > a:
  for i in range(b):
    numlist.append(str(a))
else:
  for i in range(a):
    numlist.append(str(b))
print("".join(numlist))
Buggy code:
a, b = map(int, input().split())

aa = ''.join([str(a) for i in range(b)])
bb = ''.join([str(b) for j in range(a)])

lst = [aa, bb]
print(sorted(lst))

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

aa = ''.join([str(a) for i in range(b)])
bb = ''.join([str(b) for j in range(a)])

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

Fixed code:
#problem-b
a,b = map(int, input().split())
print(str(a)*b if a<=b else str(b)*a)
Buggy code:
a, b = [int(i) for i in input().split()]

if(a > b):
#    for j in range (a):
    print(str(b)*a)

if(a < b):
    #for k in range (b):
    print(str(a)*b)


Fixed code:
a, b = [int(i) for i in input().split()]

if(a > b):
#    for j in range (a):
    print(str(b)*a)

elif(a <= b):
    #for k in range (b):
    print(str(a)*b)
Buggy code:
a,b = map(int,input().split())
A = ""
B = ""
for i in range(0,b):
    A += str(b)
for j in range(0,a):
    B += str(a)
print(sorted([A,B])[0])

Fixed code:
a,b = map(int,input().split())
A = ""
B = ""
for i in range(0,b):
    A += str(a)
for j in range(0,a):
    B += str(b)
print(sorted([A,B])[0])
Buggy code:
a,b = map(int, input().split())

l = "a"*b
m = "b"*a

if l < m:
    print(l)
else:
    print(m)

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

l = str(a)*b
m = str(b)*a

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

Fixed code:
a, b = map(int, input().split())
print(str(min(a, b))*max(int(a), int(b)))
Buggy code:
a, b = [int(x) for x in input().split()]
if a <= b:
  return str(a) * b
else:
  return str(b) * a

Fixed code:
a, b = [int(x) for x in input().split()]
if a <= b:
  print(str(a) * b)
else:
  print(str(b) * a)
Buggy code:
a, b = input().split()
atxt, btxt = "", ""
for i in range(int(b)):
  atxt += a
for i in range(int(a)):
  btxt += a
if atxt <= btxt:
  print(atxt)
else:
  print(btxt)

Fixed code:
a, b = input().split()
atxt, btxt = "", ""
for i in range(int(b)):
  atxt += a
for i in range(int(a)):
  btxt += b
if atxt <= btxt:
  print(atxt)
else:
  print(btxt)
Buggy code:
def LI():
  return [int(s) for s in input().split()]
a,b = LI()

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

Fixed code:
def LI():
  return [int(s) for s in input().split()]
a,b = LI()

if a <= b:
  print(str(a)*b)   
else:
  print(str(b)*a)
Buggy code:
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''


a, b = map(int,input().split())
res = ''
if a<=b:
	for _ in range(b):
		res += 'b'
else:
	for _ in range(a):
		res += 'b'
print(res)

Fixed code:
'''
INPUT SHORTCUTS
N, K = map(int,input().split())
N ,A,B = map(int,input().split())
string = str(input())
arr = list(map(int,input().split()))
N = int(input())
'''


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


Fixed code:
a,b=map(int,input().split())
n=""
if a>b:
    for i in range(a):
        n=(str(n)+str(b))
    print(n)
else:
    for i in range(b):
        n=(str(n)+str(a))
    print(n)
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())
c=min(a,b)
d=max(a,b)
e=""
for i in range(d):
  e+=str(d)
  
print(e+"\n")

Fixed code:
a,b=map(int,input().split())
c=min(a,b)
d=max(a,b)
e=""
for i in range(d):
  e+=str(c)
  
print(e+"\n")
Buggy code:
a, b = map(int, input().split())

la = ''
lb = ''

for i in range(b):
    la += a
    lb += b

if a <= b:
    print(la)
else:
    print(lb)



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

la = ''
lb = ''

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

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

if a <= b:
    print(la)
else:
    print(lb)
Buggy code:
a,b=list(map(int,input().split()))
A=B=''
for i in range(b+1):
  A=A+str(a)
for i in range(a+1):
  B=B+str(b)

print(min(A,B))

Fixed code:
a,b=list(map(int,input().split()))
A=B=''
for i in range(b):
  A=A+str(a)
for i in range(a):
  B=B+str(b)

print((min(A,B)))
Buggy code:
a,b = input().split()

a_ = a * int(a)
b_ = b * int(b)

moji = sorted([a_ ,b_])

print(mojj[0])

Fixed code:
a,b = input().split()
 
a_ = a * int(b)
b_ = b * int(a)
 
moji = sorted([a_ ,b_])
 
print(moji[0])
Buggy code:
def main():
  a,b = map(int,input().split())
  ans = check(a,b)
  print(ans)
  
def check(n,m):
    num = ""
    if n < m:
        for i in range(m):
            num = str(num) + str(n)
        return num
    elif n > m:
        for i in range(n):
            num = str(num) + str(m)
        return num

main()

Fixed code:
def main():
  a,b = map(int,input().split())
  ans = check(a,b)
  print(ans)
  
def check(n,m):
    num = ""
    if n < m:
        for i in range(m):
            num = str(num) + str(n)
        return num
    elif n > m:
        for i in range(n):
            num = str(num) + str(m)
        return num
    else:
        for i in range(n):
            num = str(num) + str(m)
        return num

main()
Buggy code:
L, R = map(int,input().split())
l = str(L)
r = str(R)
last_l = ""
last_r = ""
for i in range(L):
    last_l += l 
for i in range(R):
    last_r += r 
    
if L > R:
    print(last_r)
else:
    print(last_l) 

Fixed code:
L, R = map(int,input().split())
l = str(L)
r = str(R)
last_l = ""
last_r = ""
for i in range(L):
    last_r += r 
for i in range(R):
    last_l += l     
if L > R:
    print(last_r)
else:
    print(last_l)
Buggy code:
a,b = list(map(int, input().split()))
print(a,b)

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)


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

if a > b:
    ans = ''
    for target_list in range(a):
        ans = ans + str(b)

    print(ans)

if b > a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
    

if b == a:
    ans = ''
    for target_list in range(b):
        ans = ans + str(a)

    print(ans)
Buggy code:
a,b = map(int, input().split())

a_str = 'a' * b
b_str = 'b' * a

if a < b:
    print(a_str)
elif b > a:
    print(b_str)
else:
    print(a_str)

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

a_str = str(a) * b
b_str = str(b) * a

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

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

print(aa if a>b else bb)

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

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

print(bb if a>b else aa)
Buggy code:
a=list(map(lambda x:x,input().split()))
if(a[1]>a[0]):
  print(str(a[0])*a[1])
else:
  print(str(a[1])*a[0])

Fixed code:
a=list(map(lambda x:x,input().split()))
if(a[1]>a[0]):
  print(a[0]*int(a[1]))
else:
  print(a[1]*int(a[0]))
Buggy code:
a,b=map(int,input().split())
print(str(max(a,b))*min(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())


s1 = ""
s2 = ""
for i in range(b):
    s1 = s1 + str(a)

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

ans = min(s1,s2)

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


s1 = ""
s2 = ""
for i in range(b):
    s1 = s1 + str(a)

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

ans = min(s1,s2)
print(ans)
Buggy code:
a, b = [input() for i in range(2)]
a_array = []
for i in range(int(b)):
    a_array.append(a)
a_str = "".join(a_array)

b_array = []
for i in range(int(a)):
    b_array.append(b)
b_str = "".join(b_array)


if a_str < b_str:
    print(a_str)
elif b_str < a_str:
    print(b_str)
else:
    print(a_str)


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

a_array = []
for i in range(int(b)):
    a_array.append(a)
a_str = "".join(a_array)

b_array = []
for i in range(int(a)):
    b_array.append(b)
b_str = "".join(b_array)


if a_str < b_str:
    print(a_str)
elif b_str < a_str:
    print(b_str)
else:
    print(a_str)
Buggy code:
A, B = map(int, input().split())
if (A==B):
    Yes=[str(A)]*A

elif (A>B):
    Yes=[str(B)]*B
else:
    Yes=[str(A)]*A

s = ''.join(Yes)
print(s)

Fixed code:
A, B = map(int, input().split())
if (A==B):
    Yes=[str(A)]*A

elif (A>B):
    Yes=[str(B)]*A
else:
    Yes=[str(A)]*B

s = ''.join(Yes)
print(s)
Buggy code:
a,b = map(int,input().split())
if a > b: a,b = b,a
for i in ragne(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=(int(x) for x in input().split())
i = 0
if a > b:
  while i < b:
    print(str(a))
    i += 1
else:
  while i < a:
    print(str(b))
    i += 1

Fixed code:
a,b=(int(x) for x in input().split())
i = 0
if a > b:
  while i < a:
    print(str(b), end="")
    i += 1
else:
  while i < b:
    print(str(a), end="")
    i += 1