Problem:
 Score : 200 points    Problem Statement Given are 1 -digit positive integers a and b . Consider these two strings: the concatenation of b copies of the digit a , and the concatenation of a copies of the digit b . Which of these is lexicographically smaller?      Constraints  1 \leq a \leq 9  1 \leq b \leq 9  a and b are integers.         Input Input is given from Standard Input in the following format:  a  b       Output Print the lexicographically smaller of the two strings. (If the two strings are equal, print one of them.)        Sample Input 1 4 3      Sample Output 1 3333  We have two strings 444 and 3333 . Between them, 3333 is the lexicographically smaller.       Sample Input 2 7 7      Sample Output 2 7777777

Solution (Python):
x, y = map(int, input().split())
if(x < y):
    for i in range(0, y):
        print(x, end = '')
else:
    for i in range(0, x):
        print(y, end = '')

Solution (Python):
a,b=map(int,input().split())
if a>b:
    a,b=b,a
for i in range(b):
    print(a,end='')

Solution (Python):
a , b = (int(a) for a in input().split())
x = min(a,b)
t = max(a,b)
ans = [str(x)]*t
print("".join(ans))

Solution (Python):
import sys 
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
a, b = map(int, readline().split())
a_st = str(a) * b 
b_st = str(b) * a
if a_st <= b_st:
    print(a_st)
else:
    print(b_st)

Solution (Python):
a,b = map(int,input().split())
if a>=b:
  print(str(b)*a)
else:
  print(str(a)*b)

Solution (Python):
a,b = map(str, input().split())
print(a*int(b) if ord(a) < ord(b) else b*int(a))

Solution (Python):
A,B = map(int, input().split())
A1,B1 = str(A), str(B)
A2 = int(str(A)*B)
B2 = int(str(B)*A)
if A2 >= B2:
  print(A2)
else:
  print(B2)

Solution (Python):
a,b = map(int,input().split())
ans_a = str(b)*a
ans_b = str(a)*b
print(min(ans_a,ans_b))

Solution (Python):
a, b = input().split()
print(str(min(int(a), int(b)))*max(int(a),int(b)))

Solution (Python):
a,b = map(int,input().split())
n = min(a,b)
m = max(a,b)
ans = ''
for i in range(m):
    ans = ans + str(n)
print(ans)

Solution (Python):

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

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

list = []
list.append(m)
list.append(n)

list.sort()
print(list[0])

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

Solution (Python):
a,b = (input().split())
print(sorted([a*int(b),b*int(a)])[0])

Solution (Python):
a,b=map(int,input().split())
if a>b:
  print(str(b)*a)
else:
  print(str(a)*b)

Solution (Python):
a,b = map(int,input().split())
print(str(min(a,b))*max(a,b))

Solution (Python):
a,b = map(int, input().split())
A = a*[b]
B = b*[a]
if a >= b:
   print("".join(map(str, A)))
else:
   print("".join(map(str, B)))

Solution (Python):
a,b=map(int,input().split())
x=str(a)*b
y=str(b)*a

if x<y:
    print(x)
else:
    print(y)

Solution (Python):
a,b = map(str,input().split())
if a >= b:
  print(b*int(a))
else:
  print(a*int(b))

Solution (Python):
a, b = list(map(int, input().split()))

ret = (str(a) * b)
if a > b:
    ret = (str(b) * a)

print("{}".format(ret))

Solution (Python):
a, b = map(str, input().split())

num1 = a * int(b)
num2 = b * int(a)
print(min(num1, num2))

Solution (Python):
a, b = map(int, input().split())

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

AB = [A,B]

print(min(AB))

Solution (Python):
a,b = map(int, input().split())
A = str(a)
B = str(b)
L = [A*b, B*a]
L.sort()
print(L[0])

Solution (Python):
A = input("")
L = A.split(" ")
a_s = ""
a = int(L[0])
b = int(L[1])

if (a < b):
    for i in range(b):
        a_s += str(a)
else:
    for i in range(a):
        a_s += str(b)

print(a_s)

Solution (Python):
a, b = map(int, input().split())
c = str(min(a, b))
print(c*max(a, b))

Solution (Python):
def solve():
    a, b = input().split()
    if a > b:
        print(b*int(a))
    else:
        print(a*int(b))


if __name__ == '__main__':
    solve()

Solution (Python):
a,b=map(int,input().split());print(str(min(a,b))*max(a,b))

Solution (Python):
a,b=list(map(int,input().split()))
a_list=[a for i in range(b)]
b_list=[b for i in range(a)]

import sys
for i in range(min(a,b)):
  if a_list[i]<b_list[i]:
    print("".join(map(str,a_list)))
    sys.exit()
  elif b_list[i]<a_list[i]:
    print("".join(map(str,b_list)))
    sys.exit()
if a<=b:
  print("".join(map(str,a_list)))
else:
  print("".join(map(str,b_list)))

Solution (Python):
a,b = list(map(int,input().split()))

print(str(min(a,b))*max(a,b))

Solution (Python):
a,b = map(int,input().split())


A = [str(a)*b,str(b)*a]
B = sorted(A)
print(B[0])

Solution (Python):
a,b = list(input().split())
x = a*int(b)
y = b*int(a)
list = [x,y]
list.sort()
print(list[0])

Solution (Python):
a,b = input().split()
x = ''
y = ''
for i in range(int(b)):
    x += a
for i in range(int(a)):
    y += b
print(min(x,y))

Solution (Python):
def smaller(a, b):
    n = min(len(a), len(b))
    for i in reversed(range(n)):
        if a[i] < b[i]:
            return True
        elif b[i] < a[i]:
            return False
    return len(a) < len(b)
    
  
    

a, b = [int(x) for x in raw_input().split()]

a_r = ''.join([str(a) for _ in range(b)])

b_r = ''.join([str(b) for _ in range(a)])

if smaller(a_r, b_r):
    print(a_r)
else:
    print(b_r)

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

Solution (Python):
a,b = map(int,input().split())
sa = a
sb = b

for i in range(b - 1):
    sa = sa * 10 + a

for i in range(a - 1):
    sb = sb * 10 + b

if a <= b:
    print(sa)
else:
    print(sb)

Solution (Python):
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)

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

Solution (Python):
a,b = input().split()
print(min(a,b) * int(max(a,b)))

Solution (Python):
a, b = input().split()
print(min(a*int(b), b*int(a)))

Solution (Python):
a, b = input().split()
print(min(a*int(b), b*int(a)))

Solution (Python):
a,b=map(int,input().split())
x = sorted([str(a)*b,str(b)*a])
print(x[0])

Solution (Python):
import sys
import  math
import fractions
from collections import defaultdict
stdin = sys.stdin
     
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))

a,b=nm()
tmp1=max(a,b)
tmp2=min(a,b)
ans=[]
for i in range(tmp1):
    ans.append(str(tmp2))

print(''.join(ans))

Solution (Python):
a,b = map(int,input().split())

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

Solution (Python):
a,b=map(int,input().split())

Min=min(a,b)
Max=max(a,b)
s=[Min]*Max
print(''.join((str(n)for n in s)))

Solution (Python):
a, b=map(int, input().split())
if a<=b:
    ans = [a for i in range(b)]
else:
    ans = [b for i in range(a)]
print(*ans, sep="")

Solution (Python):
a,b=input().split()
if a<b:
  print(a*int(b))
else:
  print(b*int(a))

Solution (Python):
def main():
    a, b = map(int, input().split())
    if a >= b:
        print(str(b)*a)
    else:
        print(str(a)*b)


    
if __name__ == "__main__":
    main()

Solution (Python):

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

x = str(min(a,b))
print(x*max(a,b))

Solution (Python):
a,b = map(int,input().split())
ahoge = ''.join([str(a) for _ in range(b)])
bhoge = ''.join([str(b) for _ in range(a)])
ans = []
ans.append(ahoge)
ans.append(bhoge)
ans.sort()
print(ans[0])

Solution (Python):
h, n = input().split()

if int(h) < int(n):
    print(h*int(n))
elif int(h) > int(n):
    print(n*int(h))
elif h == n:
    print(h*int(h))

Solution (Python):
a,b = input().split()
n = int(a)
m = int(b)
A = a*m
B = b*n

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

Solution (Python):
a, b = map(int, input().split())
print(''.join([str(a)]*b)) if a <= b else print(''.join([str(b)]*a))

Solution (Python):
a, b=input().split()
print(a * int(b) if a * int(b) < b * int(a) else b * int(a))

Solution (Python):
num = input().split()

a = num[1]*int(num[0])
b = num[0]*int(num[1])

print(min(a,b))

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

Solution (Python):
a,b = map(int,input().split())
c,d = min(a,b),max(a,b)
for i in range(d):
    print(str(c),end="")

Solution (Python):
a,b=map(int,input().split())

a_str=''
b_str=''
for i in range(b):
  a_str+=str(a)
for i in range(a):
  b_str+=str(b)

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

Solution (Python):
import sys
input = lambda: sys.stdin.readline().rstrip()

def main():
    a, b = map(int, input().split())
    num = sorted([str(a) * b, str(b) * a])
    print(num[0])

if __name__ == '__main__':
    main()

Solution (Python):
"""
N = list(map(int,input().split()))
S = [str(input()) for _ in range(N)]
S = [list(map(int,list(input()))) for _ in range(h)] 
print(*S,sep="")
"""

import sys
sys.setrecursionlimit(10**6)
input = lambda: sys.stdin.readline().rstrip()
inf = float("inf") 

a,b = input().split()

a,b = int(a*int(b)),int(b*int(a))
print(max([a,b]))

Solution (Python):
a, b = input().split()
an, bn = int(a), int(b)
 
ab = a * bn
ba = b * an
 
if ab >= ba:
  print(ba)
else:
  print(ab)

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a = sorted(input().split())
print(a[0] * int(a[1]))

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

Solution (Python):
def actual(a, b):
    str_ab = str(a) * b
    str_ba = str(b) * a

    return min(str_ab, str_ba)

a, b = map(int, input().split())
print(actual(a, b))

Solution (Python):
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)

Solution (Python):
a,b=map(int,input().split())
print(str(min(a,b))*max(a,b))

Solution (Python):
a,b=map(int,input().split())
ans=0
l=[]
for i in range(b):
  i=a
  l.append(str(i))
ans=','.join(l)
ans_1=ans.replace(',','')

new_l=[]
for i in range(a):
  i=b
  new_l.append(str(i))
new_ans=','.join(new_l)
ans_2=new_ans.replace(',','')

if a == b:
  print(ans_1)
  
elif a > b:
  print(ans_2)
  
else:
  print(ans_1)

Solution (Python):
import sys
input = sys.stdin.readline

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

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

Solution (Python):
a,b = map(int,input().split())
if a>=b:
    ans = [str(n) for n in [b]*a]
    print("".join(ans))
else:
    ans = [str(n) for n in [a]*b]
    print("".join(ans))

Solution (Python):
a, b = map(int, input().split())
if a >= b:
  print(str(b) * a)
elif a < b:
  print(str(a) * b)

Solution (Python):
import sys

input = lambda: sys.stdin.readline().rstrip()


def solve():
    a, b = map(int, input().split())
    if a < b:
        ans = str(a) * b
    else:
        ans = str(b) * a
    print(ans)


if __name__ == '__main__':
    solve()

Solution (Python):
a,b=map(int,input().split())

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

Solution (Python):
def main():
    a, b = input().split()

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


if __name__ == "__main__":
    main()

Solution (Python):
a,b=input().split()
if int(a)<int(b):
  print(a*int(b))
else:
  print(b*int(a))

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

Solution (Python):
a, b = map(int,input().split())
A = str(a)
B = str(b)
X = A * b
Y = B * a

L = []
L.append(X)
L.append(Y)

L.sort()

print(L[0])

Solution (Python):
a,b = input().split()

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

Solution (Python):
a, b = map(int, input().split())

if a == b:
    print(str(a) * b)
else:
    l = []
    l.append(str(a) * b)
    l.append(str(b) * a)
    l.sort()
    print(l[0])

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

Solution (Python):
a, b = input().split()
if a < b:
    print(a*int(b))
else :
    print(b*int(a))

Solution (Python):
a,b=map(int,input().split())

ab=""
ba=""
for _ in range(b):
    ab+=str(a)

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

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

Solution (Python):
a,b=input().split()
A=int(a); B=int(b);
if(a*B<=b*A):
  print(a*B)
else:
  print(b*A)

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

DIC=[A,B]
DIC=sorted(DIC)
print(DIC[0])

Solution (Python):
import sys
import decimal 

def input():
    return sys.stdin.readline().strip()

def main():
    a, b =  input().split()
    if int(a) <= int(b):
        for i in range(int(b)):
            print(a, end="")
        return
    for i in range(int(a)):
            print(b, end="")
    

main()

Solution (Python):
a, b = map(int, input().split())

a_l = []
b_l = []

for i in range(a):
    a_l += str(b)
    
for i in range(b):
    b_l += str(a)
    
a_l = ''.join(a_l)    
b_l = ''.join(b_l)

all = []
all.append(a_l)
all.append(b_l)
all.sort()
print(all[0])

Solution (Python):
a, b = map(int, input().split())

l, n = (a, b) if a > b else (b, a) 

ans = ''
for i in range(l):
  ans += str(n)
  
print(ans)

Solution (Python):
a,b = input().split()
aa = a*int(b)
bb = b*int(a)
if aa >= bb:
    print(bb)
else:
    print(aa)

Solution (Python):
a,b = input().split()
print(min(a*int(b),b*int(a)))

Solution (Python):
a, b = map(int, input().split())
print(str(min(a,b))*max(a,b))

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

Solution (Python):

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

Solution (Python):
a,b = input().split()

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

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

Solution (Python):

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

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

Solution (Python):
a, b = (int(x) for x in input().split())

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

Solution (Python):
a,b = input().split()
print(min(a * int(b), b * int(a)))

Solution (Python):

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

if a<b:
    print(int(a*(10**b-1)/9))
else:
    print(int(b*(10**a-1)/9))

Solution (Python):
a, b = input().split()
print(min(a*int(b), b*int(a)))

Solution (Python):
N,M=input().split()
L=[N,M]
L=sorted(L)
print(L[0]*int(L[1]))

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a,b = map(int, input().split())
num='123456789'

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

Solution (Python):
def main():
    n,m = map(int,input().split())
    if n > m:
        n, m = m, n

    print(str(n) * m)
    

if __name__ == "__main__":
    main()

Solution (Python):
a, b = input().split()
print(min(b * int(a), a * int(b)))

Solution (Python):
a,b=input().split()
num_a=int(a*int(b))
num_b=int(b*int(a))

if num_a>num_b:
    print(num_a)
elif num_a<num_b:
    print(num_b)
else:
    print(num_a)

Solution (Python):
a, b = input().split()
print(min(a*int(b), b*int(a)))

Solution (Python):
A, B = input().split()
print(min(A*int(B), B*int(A)))

Solution (Python):

a, b = input().split()
aa = a * int(b)
bb = b * int(a)
templist = [aa, bb]
templist.sort()
print(templist[0])

Solution (Python):
a,b = map(int,input().split())

x = [''] * 2
for i in range(b):
  x[0] += str(a)
for i in range(a):
  x[1] += str(b)

print(sorted(x)[0])

Solution (Python):
a,b = input().split()
print(a*int(b) if a < b else b*int(a))

Solution (Python):
a, b = map(int, input().split())

if a == min(a, b):
    tmp_a = 0
    for i in range(b):
        tmp_a += a*(10**i)
    print(tmp_a)
else:
    tmp_b = 0
    for i in range(a):
        tmp_b += b*(10**i)
    print(tmp_b)

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

Solution (Python):
a, b = map(int, input().split())
s = str(a) * b
t = str(b) * a
ans = min(s, t)
print(ans)

Solution (Python):
a, b = map(int, input().split())
s = str(a) * b
t = str(b) * a
ans = sorted([s, t])[0]
print(ans)

Solution (Python):
def main():
    a,b = input().split()
    x1 = a*int(b)
    x2 = b*int(a)
    list = sorted([x1,x2])
    print(list[0])

main()

Solution (Python):
a, b = map(int, input().split())
print("{}".format(str(min(a, b)) * max(a, b)))

Solution (Python):

import sys

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


def main():
    a, b = map(int, readline().split())

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


if __name__ == '__main__':
    main()

Solution (Python):
i,j = list(map(int, input().split()))
if j<i:
    a=str(j)
    print(a*i)
else:
    a=str(i)
    print(a*j)

Solution (Python):
a,b = map(int,input().split())
aa = [a]*b
bb = [b]*a
print(*min(aa,bb),sep = "")

Solution (Python):
a,b = map(int, input().split())
print(str(min(a,b))*max(a,b))

Solution (Python):
a,b=map(str,input().split())
A=a*int(b)
B=b*int(a)
print(min(A,B))

Solution (Python):
a, b = map(int, input().split())

lis = list()

lis.append(str(a)*int(b))

lis.append(str(b)*int(a))

lis.sort()

print(lis[0])

Solution (Python):
a, b = map(str, input().split())
A = ''
B = ''

for i in range(int(b)):
    A += a
for i in range(int(a)):
    B += b

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

Solution (Python):
a, b = input().split()
if a > b:
    print(b*int(a))
else:
    print(a*int(b))

Solution (Python):
a, b = list(map(int, input().split()))
p = str(b)*a
q = str(a)*b
if p < q:
    print(p)
else:
    print(q)

Solution (Python):
a, b = map(int, input().split())

t= sorted([str(a)*b, str(b)*a])
print(t[0])

Solution (Python):
a,b=input().split()
print(min(a*int(b),b*int(a)))

Solution (Python):
a,b = input().split(' ')
if a < b:
  print(a * int(b))
else:
  print(b * int(a))

Solution (Python):
ii = lambda : int(input())
mi = lambda : map(int,input().split())
li = lambda : list(map(int,input().split()))

a,b = mi()
c = ''
if a <= b:
    for i in range(b):
        c += str(a)
else:
    for i in range(a):
        c += str(b)

print(c)

Solution (Python):
x = input().split()
a = ''
b = ''
for i in range(0, int(x[1])):
  a += x[0]
for i in range(0, int(x[0])):
  b += x[1]
if a > b:
  print(b)
else:
  print(a)

Solution (Python):
a, b = input().split()
s1 = int(a) * b
s2 = int(b) * a
print(s1 if s1 < s2 else s2)

Solution (Python):
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)

Solution (Python):
n1, n2 = [int(i) for i in input().split()]

r1 = ""
if n1 <= n2:
    for i in range(n2):
        r1 += str(n1)
else:
    for i2 in range(n1):
        r1 += str(n2)
print(r1)

Solution (Python):
a,b = input().split()

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

print(max(ab,ba))

Solution (Python):
a,b=input().split()
print( b*int(a) if a>b else a*int(b))

Solution (Python):
a,b = map(int,input().split())
ans = []
if a < b:
    for i in range(b):
        ans.append(a)
elif a >= b:
    for i in range(a):
        ans.append(b)
print(''.join(map(str, ans)))

Solution (Python):
a, b = input().split()
print(a*int(b) if a < b else b*int(a))

Solution (Python):
a, b = map(int, input().split())
a_str = str(a)
b_str = str(b)
for i in range(b-1):
  a_str += str(a)
for i in range(a-1):
  b_str += str(b)
ans = sorted([a_str, b_str])
print(ans[0])

Solution (Python):
a, b = map(int, input().split())
print(str(a)*b if b >= a else str(b)*a)

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

Solution (Python):
a, b = map(int, input().split())


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

Solution (Python):
a,b=input().split()

li=[a*int(b),b*int(a)]
li.sort()

print(li[0])

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

Solution (Python):
def main():
    a, b = input().split()
    i, j = a, b
    for _ in range(1, int(j)):
        a += i
    for _ in range(1, int(i)):
        b += j
    ans = [a,b]
    print(sorted(ans)[0])

if __name__ == '__main__':
    main()

Solution (Python):
n,m=map(int,input().split())
l=[str(n)*m,str(m)*n]
l.sort()
print(l[0])

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a, b = map(int, input().split())
print(min(str(a)*b, str(b)*a))

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a,b = map(int,input().split())
count = 0
if a > b :
    count = str(b)*a
else :
    count = str(a)*b
print(count)

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

Solution (Python):
a, b = map(int, input().split())
s = a
t = b
for i in range(b - 1):
    s = s * 10 + a
for i in range(a - 1):
    t = t * 10 + b
if s > t:
    print(s)
else:
    print(t)

Solution (Python):
A = list(map(int, input().split()))

print(str(min(A))*max(A))

Solution (Python):
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])

Solution (Python):
a, b = input().split()

print( min(a,b) * int(max(a,b)) )

Solution (Python):
a,b = map(int,input().split())
print(str(min(a,b))*max(a,b))

Solution (Python):
a,b = input().split()
if int(a) <= int(b):
    print(a * int(b))
else:
    print(b * int(a))

Solution (Python):
import sys

def ILI(): return list(map(int, sys.stdin.readline().rstrip().split()))

a, b = ILI()
A = str(a)*b
B = str(b)*a
if b>a:print(A)
else:print(B)

Solution (Python):
import collections
a,b = map(int, raw_input().split(' '))
if a <= b:
	print str(a) * b
else:
	print str(b) * a

Solution (Python):
a, b = map(int, input().split())

str_a = str(a)
str_b = str(b)

line_a = str_a*b
line_b = str_b*a

lines = [line_a, line_b]
sorted_lines = sorted(lines)

print(sorted_lines[0])

Solution (Python):


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

Solution (Python):
a,b = input().split()
print(min(a*int(b),b*int(a)))

Solution (Python):
a,b=input().split()
A=a*int(b)
B=b*int(a)
if a<b or b<a:
    print(min(a,b)*int(max(a,b)))
else:
    print(a*int(a))

Solution (Python):

a,b = list(map(int, input().split()))
print(min(str(a)*b, str(b)*a))

Solution (Python):
a, b = map(int, input().split())
if a > b:
    print(str(b) * a)
else:
    print(str(a) * b)

Solution (Python):
a, b = map(int, input().split())
r = str(min(a, b))*max(a, b)
print(r)

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)

def LI(): return list(map(int, stdin.readline().split()))
def LS(): return list(stdin.readline())

a,b = LI()
print(''.join(sorted([str(a)*b, str(b)*a])[0]))

Solution (Python):
a, b = map(int, input().split())
l = [str(a)*b, str(b)*a]
l.sort()
print(l[0])

Solution (Python):
a,b =map(str,input().split())
d=[a*int(b),b*int(a)]
d.sort()
print(d[0])

Solution (Python):
a,b=input().split()

c=a*int(b)
d=b*int(a)
A=[c,d]

print(sorted(A)[0])

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
a, b = map(str, input().split())

num1 = a * int(b)
num2 = b * int(a)

num = sorted([num1, num2])
print(num[0])

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

Solution (Python):
a,b=input().split()
if a<b:
    print(a*int(b))
else:
    print(b*int(a))

Solution (Python):
a,b=input().split()
print([a*int(b), b*int(a)][a>=b])

Solution (Python):
a, b = map(int, input().split())
a1 = str(b) * a
b1 = str(a) * b

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

Solution (Python):
a, b = map(int, input().split())

print(str(min(a, b)) * max(a, b))

Solution (Python):
a, b = map(int, input().split())

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

Solution (Python):
import sys
input = sys.stdin.readline


def main():
    a, b = map(int, input().split())
    A = "".join([str(a)]*b)
    B = "".join([str(b)]*a)
    print(A) if A < B else print(B)


if __name__ == '__main__':
    main()

Solution (Python):
a, b = map(int, input().split())
def result(n, m):
    s = ''
    for i in range(m):
        s += str(n)
    return s
if a <= b:
    ans = result(a, b)
else:
    ans = result(b, a)
print(ans)

Solution (Python):
a, b = list(map(int, input().split()))
print([str(a) * b, str(b) * a][int(str(a) * b > str(b) * a)])

Solution (Python):
a, b = map(int, input().split())
if a <= b:
    print(''.join([str(a) for _ in range(b)]))
else:
    print(''.join([str(b) for _ in range(a)]))

Solution (Python):
a,b = (int(x) for x in input().split())

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

Solution (Python):
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")

Solution (Python):
a, b = map(int, input().split())

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

if ab >= ba:
    print(int(ba))
else:
    print(int(ab))

Solution (Python):
a,b = map(int, input().split())
ab = []
ba = []
ans = []
for i in range(b):
    ab.append(str(a))
for i in range(a):
    ba.append(str(b))
ans.append(''.join(ab))
ans.append(''.join(ba))
new = sorted(ans)
print(new[0])

Solution (Python):




def input_int():
    return int(input())



def int1(x):
    return int(x) - 1



def input_to_int_map():
    return map(int, input().split())



def input_to_int_tuple():
    return tuple(map(int, input().split()))



def input_to_int_tuple_minus1():
    return tuple(map(int1, input().split()))


def main():
    a, b = input_to_int_map()
    import itertools
    _a = "".join(itertools.repeat(str(a), b))
    _b = "".join(itertools.repeat(str(b), a))
    ret = _b
    if _a < _b:
        ret = _a

    return ret


if __name__ == "__main__":
    print(main())

Solution (Python):
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)

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

Solution (Python):
a,b = input().split()
print(min(a*int(b),b*int(a)))

Solution (Python):
a,b=map(int,input().split())
if a>=b:
    print(str(b)*a)
else:
    print(str(a)*b)

Solution (Python):
a,b=map(int,input().split())
if a>=b:
    print(str(b)*a)
else:
    print(str(a)*b)

Solution (Python):
n=2
a=[0]*n
a[:]=map(int,input().split())
a.sort()
print(str(a[0])*a[1])

Solution (Python):
a,b=map(int,input().split())
x=[str(a)]*b
x_=''.join(x)
y=[str(b)]*a
y_=''.join(y)
ans=sorted([x_,y_])
print(ans[0])

Solution (Python):
a, b = map(int, input().split())
A, B = 0, 0
for i in range(b):
    A += a * (10 ** i)
for i in range(a):
    B += b * (10 ** i)
if str(A) < str(B):
    print(A)
else:
    print(B)

Solution (Python):
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)

Solution (Python):
a, b = input().split()
x = a * int(b)
y = b * int(a)
print(x if x < y else y)

Solution (Python):
a,b = map(int,input().split())
answer = 0
if a ==b:
    for i in range(a):
        answer += a*10**(i)
if a > b:
    for i in range(a):
        answer += b*10**(i)
if a < b:
    for i in range(b):
        answer += a*10**(i)
print(answer)

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

Solution (Python):
a,b = map(int,input().split())
print(sorted([str(a)*b,str(b)*a])[0])

Solution (Python):
a, b = input().split()

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