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):
a,b=map(int,input().split())
A=str(a)*b
B=str(b)*a
l=[A,B]

l.sort()

print(l[0])

Solution (Python):

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

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

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

if a < b:
    small = a
    large = b
else:
    small = b
    large = a

for i in range(large):
    print(small, end="")
print()

Solution (Python):
def solve():
    a,b = input().split()
    cnt_a = int(a)
    cnt_b = int(b)
    tmpa = a*cnt_b
    tmpb=b*cnt_a
    res = min(tmpa,tmpb)
    print(res)
if __name__ == "__main__":
    solve()

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

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

c = min(a,b)
d = max(a,b)
s= ''
for i in range(d):
  s+=str(c)
  
print(s)

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

mojia = list([a]*b)
mojib = list([b]*a)

if a <= b:
    ma = map(str, mojia)
    print("".join(ma))
else:
    mb = map(str, mojib)
    print("".join(mb))

Solution (Python):
a, b = [i for i in input().split()]
print(max(int(a * int(b)), int(b * int(a))))

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

if a>b:
  B=0
  c=1
  for i in range(a):
    B+=b*c
    c=c*10
  print(B)
else:
  A=0
  c=1
  for i in range(b):
    A+=a*c
    c=c*10
  print(A)

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

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

Solution (Python):
ab=list(map(int,input().strip().split()))
a=ab[0]
b=ab[1]

if a<=b:
    print(int(str(a)*b))
else:
    print(int(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 = input().split()

if min(a, b) == a:
    print(a * int(b))
else:
    print(b * int(a))

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

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

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

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

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())
print(*[min(a, b)] * max(a, b), sep='')

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())

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

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

L=[sa,sb]
L=sorted(L)
print(L[0])

Solution (Python):

import sys


def solve(a: int, b: int):
    print(sorted([a*int(b), b*int(a)])[0])
    return



def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    a = next(tokens)  
    b = next(tokens)  
    solve(a, b)


if __name__ == '__main__':
    main()

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):
N, M = input().split()
if N*int(M) < M*int(N):
  print(N*int(M))
else:
  print(M*int(N))

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

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

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

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

Solution (Python):
def main():
    a, b = map(int, input().split())
    s = ""
    if a > b:
        for i in range(a):
            s += str(b)
    else:
        for i in range(b):
            s += str(a)
    print(s)


if __name__ == "__main__":
    main()

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

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

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())
ab = str(a)*b
ba = str(b)*a
if ab > ba:
    print(ba)
else:
    print(ab)

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

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

aa = ''
bb = ''
for i in range(b):
    aa += sa
for i in range(a):
    bb += sb

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

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

Solution (Python):
def main():
    a, b = map(int, input().split())
    A = ""
    B = ""
    for _ in range(b):
        A += str(a)

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

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

main()

Solution (Python):
def resolve():

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

resolve()

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

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

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

Solution (Python):
import sys

def solve():
    a, b = input().split()
    D = [a * int(b), b * int(a)]
    D.sort()
    print(D[0])

    return 0

if __name__ == "__main__":
    solve()

Solution (Python):
a, b = map(int, input().split())
L = [str(a)*b, str(b)*a]
L.sort()
print(L[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())
print(''.join(map(str,[min(a,b) for i in range(max(a,b))])))

Solution (Python):
A,B=map(int,input().split())
C=int(str(A)*B)
D=int(str(B)*A)
E=[C,D]
F=sorted(E)
print(int(F[1]))

Solution (Python):



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


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


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

Solution (Python):
a,b=map(int,input().split())
l=["",""]
for i in range(a):
    l[0]=l[0]+str(b)
for i in range(b):
    l[1]=l[1]+str(a)
l.sort()
print(l[0])

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=str(a)*b
d=str(b)*a
print(c if c<d else d)

Solution (Python):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians, acos, atan, asin
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
def input(): return sys.stdin.readline().strip()
def STR(): return input()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))
sys.setrecursionlimit(10 ** 9)
inf = sys.maxsize
mod = 10 ** 9 + 7
dx = [0, 0, 1, -1, 1, -1, -1, 1]
dy = [1, -1, 0, 0, 1, -1, 1, -1]

a, b = MAP()
ans1 = ''
ans2 = ''
for i in range(b):
    ans1 += str(a)
for i in range(a):
    ans2 += str(b)
print(min(ans1, ans2))

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

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

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


S = [str(a) * b, str(b) * a]
S.sort()
print(S[0])

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

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

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

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

Solution (Python):
import sys
input=sys.stdin.readline
a,b=map(int,input().split())
x=str(a)*b
y=str(b)*a
if x<y:
    print(x)
else:
    print(y)

Solution (Python):
def ii():return int(input())
def iim():return map(int,input().split())
def iil():return list(map(int,input().split()))

a,b = iim()
print(str(min(a,b))*max(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()
if a < b:
    print(a * int(b))
else:
    print(b * int(a))

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

    str_ba = str(b) * a
    str_ab = str(a) * b

    if str_ab > str_ba:
        print(str_ba)
    else:
        print(str_ab)


if __name__ == '__main__':
    main()

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

Solution (Python):
n,m =list(map(int,input().split()))
if n>m:
    for i in range (n):print(m,end="")
else:
    for i in range(m):print(n,end="")

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())
print(str(min(a, b)) * max(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 = (x for x in input().split(" "))


S = [ a*int(b) , b*int(a) ]

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

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

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

for i in range(a):
  c+=b*(10**i)

d=0
for j in range(b):
  d+=a*(10**j)

e=c if b<a else d
print(e)

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

s_a = str(a) * b
s_b = str(b) * a

if s_a < s_b:
    print(s_a)
else:
    print(s_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())
print(str(min(a,b))*max(a,b))

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

Solution (Python):
if __name__ == '__main__':

	n,m = map(int,input().split())

	A = []
	A.append(str(n) * m)
	A.append(str(m) * n)

	A = sorted(A)
	print(A[0])

Solution (Python):
ab=input().rstrip().split(" ")
a=int(ab[0])
b=int(ab[1])
string=""
if a>b:
    for i in range(a):
        string=string+str(b)
elif a==b:
    for i in range(a):
        string=string+str(a)
elif a<b:
    for i in range(b):
        string=string+str(a)
print(string)

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

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

Solution (Python):
a, b = list(map(int,input().split()))
A = [a for _ in range(b)]
B = [b for _ in range(a)]
m = ''.join(map(str,A))
n = ''.join(map(str,B))
list = [m,n]
L = sorted(list)
print(L[0])

Solution (Python):
a, b = input().split()
a_b = a * int(b)
b_a = b * int(a)
ans = [a_b, b_a]
ans.sort()
print(ans[0])

Solution (Python):
a, b = map(int, input().split())
min_num = min(a,b)
max_num = max(a,b)
str_num = ""
for i in range(max_num):
  str_num = str_num + str(min_num)
print(str_num)

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

Solution (Python):

a,b = map(int,input().split())
a1 = []
b1 = []
if a <= b:
    for i in range(b):
        a1.append(a)
    a1 = [str(m) for m in a1]
    print(''.join(a1))
elif b < a:
    for i in range(a):
        b1.append(b)
    b1 = [str(m) for m in b1]
    print(''.join(b1))

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

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(b)*a)
else:
  print(str(a)*b)

Solution (Python):
a,b=map(int,input().split())
if a<b:
  for _ in range(b):
    print(a,end="")
else:
  for _ in range(a):
    print(b,end="")

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

Solution (Python):
a,b=[int(s) for s in input().split()]
m=min([a,b])
M=max([a,b])
print(m*(10**M-1)//9)

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

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

Solution (Python):




def resolve():
    a, b = map(int, input().split())
    str_a = str(a)
    str_b = str(b)

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

    print(ans)



if __name__ == "__main__":
    resolve()

Solution (Python):
a,b = [int(i) for i in input().split()]
if (a > b) :
    a,b = b,a

print(str(a) * b)

Solution (Python):



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

if a >= b : 
    num_large = a
    num_small = str(b)
else : 
    num_large = b
    num_small = str(a)

print(num_small * num_large)

Solution (Python):
n , m = map(int,input().split(" "))

if n > m:
    for i in range(n):
        print(str(m),end="")
elif n <= m:
    for i in range(m):
        print(str(n),end="")

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

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

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

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())
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):
ab = input().split()

a = int(ab[0])
b = int(ab[1])

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

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

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

Min = min(a, b)
Max = max(a, b)

print(str(Min)*Max)

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

a_s = str(a) * b
b_s = str(b) * a

ls = [a_s,b_s]
ls.sort()

print(ls[0])

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

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

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

print(sorted(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 = input().split()
aa = ''
bb = ''
for i in range(int(b)):aa+=a
for i in range(int(a)):bb+=b
if ord(a) < ord(b):
    print(int(aa))
else:
    print(int(bb))

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

Solution (Python):

from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations
import sys
import math
import bisect


def LI(): return [int(x) for x in sys.stdin.readline().split()]


def I(): return int(sys.stdin.readline())


def LS(): return [list(x) for x in sys.stdin.readline().split()]


def S():
	res = list(sys.stdin.readline())
	if res[-1] == "\n":
		return res[:-1]
	return res


def IR(n):
	return [I() for i in range(n)]


def LIR(n):
	return [LI() for i in range(n)]


def SR(n):
	return [S() for i in range(n)]


def LSR(n):
	return [LS() for i in range(n)]


sys.setrecursionlimit(1000000)
mod = 1000000007


def solve():
	a, b = LI()
	ansa = str(a) * b
	ansb = str(b) * a
	print(min(ansa,ansb))
	return



if __name__ == "__main__":
	solve()

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

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

x = str(a) * b
y = str(b) * a
ans = min(x, y)

print(ans)

Solution (Python):

a, b = input().split()
ab = a * int(b)
ba = b * int(a)
print(ab if ab < ba else ba)

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

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

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

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

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

Solution (Python):
ab= input ().split ()
a= int (ab[0])
b= int (ab[1])
if (a<=b):
    c= str(a)
    print(c*b)
if (a>b):
    c= str(b)
    print (c*a)

Solution (Python):
tmp= input().split()
a=int(tmp[0])
c=tmp[0]
b=int(tmp[1])
d=tmp[1]

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

Solution (Python):
l = list(input().split())
N = int(l[0])
M = int(l[1])
str1 = ''
if (N <= M) :
    for i in range (M) :
        str1 = str1 + str(N)
    print (str1)
else :
    for i in range (N) :
        str1 = str1 + str(M)
    print (str1)

Solution (Python):
r = list (map (int, input ().split ()))
if (r[0] > r[1]) :
    r[0] ^= r[1]
    r[1] ^= r[0]
    r[0] ^= r[1]

print (str (r[0]) * r[1])

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

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

print(min(x, y))

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(a)*b)
else:
  print(str(b)*a)

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

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

sa = ''
sb = ''
for i in range(b) :
  sa += str(a)

for i in range(a) :
  sb += str(b)
  
print(min(sa,sb))

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

s_a, s_b = '', ''
for i in range(b):
    s_a += str(a)
for i in range(a):
    s_b += str(b)
if s_a < s_b:
    print(s_a)
else:
    print(s_b)

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

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()
l,r='',''
for i in range(int(b)): l+=a
for i in range(int(a)): r+=b
print(min(l,r))

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

Solution (Python):
A,B = input().split()
Aint = ''
Bint = ''

for i in range(int(B)):
  Aint += A
for i in range(int(A)):
  Bint += B
if Aint <= Bint:
  print(Aint)
else:
  print(Bint)

Solution (Python):

a,b = input().split()

aa = a * int(b)
bb = b * int(a)
print(min(aa,bb))

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

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

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

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

A_list=[str(a)]*b
B_list=[str(b)]*a

C=[]
C.append("".join(A_list))
C.append("".join(B_list))

C.sort()

print(C[0])

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

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

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

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

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

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

x=a*int(b)
y=b*int(a)

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

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

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

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

if  str(a)*b > str(b)*a:
    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):
  for i in range(int(A)):
    print(B,end="");
else:
  for i in range(int(B)):
    print(A,end="");

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

if a == b:
    print(str(a) * b)
    sys.exit()
print(str(min(a, b)) * max(a, b))

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

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

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

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

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

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

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

if A < B:
    aList = [str(A) for i in range(B)]
    print(''.join(aList))
else:
    bList = [str(B) for i in range(A)]
    print(''.join(bList))

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

Solution (Python):

a, b = [int(i) for i in input().split(' ')]
a_b = str(a) * b
b_a = str(b) * a
if a_b < b_a:
    print(a_b)
else:
    print(b_a)

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 = input().split()
c = a * int(b)
d = b * int(a)
if int(c) >= int(d):
  print(int(c))
else:
  print(int(d))

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

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

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

Solution (Python):
a, b = map(int, input().split())
s = [str(a)*b, str(b)*a]
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())

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

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

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

Solution (Python):
def get_ints():
    return map(int, input().split())

a, b = get_ints()
s = str(a) * b
t = str(b) * a
print(min(s, t))

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):


def solve():
    a, b = list(map(int, input().split()))
    ans1 = str(a)*b
    ans2 = str(b)*a

    ans = ans1 if ans1 < ans2 else ans2
    print(ans)


if __name__ == "__main__":
    solve()

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

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)

Solution (Python):

A, B = map(int, input().split())

ans = ""
if(A>B):
  for i in range(A):
    ans = ans + str(B)
else:
  for i in range(B):
    ans = ans + str(A)
    
    
    
print(ans)

Solution (Python):
import sys
import itertools
input = sys.stdin.readline
sys.setrecursionlimit(100000)
mod = 10 ** 9 + 7


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


def read_index():
    return map(lambda x: x - 1, map(int, input().split()))


def read_list():
    return list(read_values())


def read_lists(N):
    return [read_list() for n in range(N)]


def functional(N, mod):
    F = [1] * (N + 1)
    for i in range(N):
        F[i + 1] = (i + 1) * F[i] % mod
    return F


def main():
    a, b = read_values()
    print(str(min(a, b)) * max(a, b))


if __name__ == "__main__":
    main()

Solution (Python):

import sys,os
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = (lambda *something: print(*something)) if 'TERM_PROGRAM' in os.environ else lambda *x: 0
def main(given=sys.stdin.readline):
    input = lambda: given().rstrip()
    LMIIS = lambda: list(map(int,input().split()))
    II = lambda: int(input())
    XLMIIS = lambda x: [LMIIS() for _ in range(x)]
    YN = lambda c : print('Yes') if c else print('No')
    MOD = 10**9+7

    a,b = LMIIS()
    if a < b:
        for i in range(b):
            write(str(a))
        print()
    else:
        for i in range(a):
            write(str(b))
        print()


    

if __name__ == '__main__':
    main()

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

Solution (Python):
from __future__ import print_function

import sys

import re
import array
import copy
import functools
import operator

import math
import string
import fractions
from fractions import Fraction
from fractions import gcd



import collections
import itertools
import bisect

import random
import time

import heapq
from heapq import heappush
from heapq import heappop
from heapq import heappushpop
from heapq import heapify
from heapq import heapreplace
from queue import PriorityQueue as pq
from queue import Queue

from itertools import accumulate

from collections import deque
from collections import Counter

from operator import mul
from functools import reduce

input = sys.stdin.readline


def eprint(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)
    return


def lcm(n, m):
    return int(n * m / gcd(n, m))


def coprimize(p, q):
    common = fractions.gcd(p, q)
    return (p // common, q // common)


def combinations_count(n, r):
    r = min(r, n - r)
    numer = reduce(mul, range(n, n - r, -1), 1)
    denom = reduce(mul, range(1, r + 1), 1)
    return numer // denom


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


if __name__ == '__main__':
    main()

Solution (Python):



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

A = ""
B = ""

for _a in range(a):
    A += str(b)
for _b in range(b):
    B += str(a)

d = [A, B]
d.sort()

print(d[0])

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

string1 = str(a) * b
string2 = str(b) * a

if string1 <= string2:
    print(string1)
else:
    print(string2)

Solution (Python):
ab = input().split(" ")

a = int(ab[0])
b = int(ab[1])

aa = 0
bb = 0

for i in range(b):
    aa = aa + a * 10**i

for i in range(a):
    bb = bb + b * 10**i

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

Solution (Python):
A,B = map(int,input().split())
if A <= B :
  out = str(A) * B
else:
  out = str(B) * A

print(out)

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

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

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

lista = [str(a)]*b

listb = [str(b)]*a


if int(''.join(lista))>=int(''.join(listb)):
    print(int(''.join(lista)))
else:
    print(''.join(listb))

Solution (Python):

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

    ans = ''
    if a >= b:
        for i in range(a):
            ans += str(b)
        print(ans)
    else:
        for i in range(b):
            ans += str(a)
        print(ans)
    


if __name__ == '__main__':
    main()

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

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

Solution (Python):
a, b = [int(i) for i in input().split()]
print(min("{}".format(a) * b, "{}".format(b) * a))

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

Solution (Python):
n, m = (input().split())
n=int(n)
m=int(m)
if n>m:
    m=str(m)
    print(m*n)
else:
    n=str(n)
    print(n*m)

Solution (Python):
import sys

stdin = sys.stdin

ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().rstrip()  


a, b = na()
n1 = ''
n2 = ''
for i in range(a):
    n1 += str(b)
for i in range(b):
    n2 += str(a)

print(min(n1, n2))

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

Solution (Python):
input_line = input()
Line = input_line.split()
Line = [int(s) for s in Line]

p =""
for i in range(max(Line)):
    p += str(min(Line))

print(p)

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

Solution (Python):
import sys
input = sys.stdin.readline
def linput():
    return list(map(int, input().split()))

def main():
    
    A,B = linput()
    
    
    

    
    
    vA = [str(A)*B, str(B)*A]
    vA.sort()
    res = vA[0]

    print(res)

main()

Solution (Python):
ii=lambda:int(input())
miis=lambda:map(int,input().split())
lmiis=lambda:list(map(int,input().split()))

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

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

    

main()

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

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

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