Problem:
 Score : 100 points    Problem Statement We have two integers: A and B .  Print the largest number among A + B , A - B , and A \times B .      Constraints  All values in input are integers.  -100 \leq A,\ B \leq 100         Input Input is given from Standard Input in the following format:  A  B       Output Print the largest number among A + B , A - B , and A \times B .        Sample Input 1 -13 3      Sample Output 1 -10  The largest number among A + B = -10 , A - B = -16 , and A \times B = -39 is -10 .       Sample Input 2 1 -33      Sample Output 2 34  The largest number among A + B = -32 , A - B = 34 , and A \times B = -33 is 34 .       Sample Input 3 13 3      Sample Output 3 39  The largest number among A + B = 16 , A - B = 10 , and A \times B = 39 is 39 .

Solution (Python):
a,b = [int(s) for s in input().split(" ")]
a_plus_b = a+b
a_minus_b = a-b
a_mul_b = a*b

max_three = max(a_plus_b, max(a_minus_b, a_mul_b))
print(max_three)

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

Solution (Python):

A,B = map(int,input().split())
print (max(A+B,A-B,A*B))

Solution (Python):
a,b = map(int, input().split())
print(max([a+b, a-b, a*b]))

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

print(max(A+B,A-B,A*B))

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

print(max(A + B, A - B, A * B))

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

print(max(A+B, max(A-B, A*B)))

Solution (Python):
import sys
sys.setrecursionlimit(2**31-1)
input = sys.stdin.readline
write = sys.stdout.write
LMIIS = lambda : list(map(int,input().split()))
II = lambda : int(input())
dbg = lambda *something : print(*something) if DEBUG is True else 0
DEBUG = True

def main():
    A,B = LMIIS()
    print(max(A+B,A-B,A*B))





    pass
if __name__ == '__main__':
    main()

Solution (Python):
def main():
    a, b = map(int, input().split())
    result = [a + b, a - b, a * b]
    print(max(result))

if __name__ == "__main__":
    main()

Solution (Python):
a,b = list(map(int,input().split()))
print(max(a+b,a-b,a*b))

Solution (Python):
A, B = map(int, input().split())
print(max(A+B, A-B, A*B))

Solution (Python):
A,B=map(int,input().split())
print(max(A+B, A-B, A*B))

Solution (Python):

A, B = list(map(int, input().split()))
print('{}'.format(max([A+B, A-B, A*B])))

Solution (Python):
def main():
    l = input().split()
    a, b = int(l[0]), int(l[1])
    x = a + b
    y = a - b
    z = a * b
    print(max(x, y, z))
    
if __name__=="__main__":
    main()

Solution (Python):

a, b = map(int, input().split())
print(max(a+b, a-b, a*b))

Solution (Python):
import numpy as np
A, B = list(map(int, input().split()))

plus = A + B
hiku = A - B
div = A * B

maxx = max(plus, max(hiku, div))
print(maxx)

Solution (Python):
A, B = [int(x) for x in input().split()]

print(max(A+B, A-B, A*B))

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

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

abp = a+b
abm = a-b
abs = a*b

if abp >= abm and abp >= abs:
  print(abp)
elif abm >= abp and abm >= abs:
  print(abm)
else:
  print(abs)

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


A, B = inpl()

print(max(A + B, A - B, A * B))

Solution (Python):
a, b = map(int, input().split())
lists = [a+b, a-b,a*b]
print(max(lists))

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

A, B = inpl()
print(max(A+B, A-B, A*B))

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

print(max(A + B, A - B, A * B))

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

add_ab = a + b
sub_ab = a - b
kake_ab = a * b

print(max(add_ab, sub_ab, kake_ab))

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

Solution (Python):
A, B = map(int, input().split())
l = [A + B, A - B, A * B]
print(max(l))

Solution (Python):
A, B = map(int, input().split())
print(max([(A + B), (A-B), (A*B)]))

Solution (Python):

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

print(max(A+B,A-B,A*B))

Solution (Python):
A, B = map(int, input().split())
print(max(A+B, A-B, A*B))

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

Solution (Python):
a, b = map(int, input().split())
print(max([(a+b), (a-b), (a*b)]))

Solution (Python):
x,y = list(map(int, input().split(" ")))

if x < 0:
    if y < 0:
        print(x*y)
    else:
        print(x+y)
else:
    if y < 0:
        print(x-y)
    else:
        ad = x+y
        mu = x*y
        if ad < mu:
            print(mu)
        else:
            print(ad)

Solution (Python):
A, B = map(int, input().split())
 
res1 = A + B
res2 = A - B
res3 = A * B
 
if res1 > res2:
  if (res1 > res3):
    print (res1)
  else:
  	print (res3)
else:
  if (res2 > res3):
    print (res2)
  else:
    print (res3)

Solution (Python):
cmdvar=input()
in_splited=cmdvar.split()

A=in_splited[0]
B=in_splited[1]

tmp=[]
tmp.append(int(A)+int(B))
tmp.append(int(A)-int(B))
tmp.append(int(A)*int(B))
ans=sorted(tmp,reverse=True)
print(ans[0])

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

Solution (Python):
a,b=map(int,input().split())
c=[a+b, a-b, a*b]
m=max(c)
print(m)

Solution (Python):
A,B = map(int,input().split())
S = A+B
L = A-B
Z = A*B
print(max(S,L,Z))

Solution (Python):
a,b=map(int,input().split())
c=[a+b, a-b, a*b]
m=max(c)
print(m)

Solution (Python):
a,b = map(int,input().split())
ans = max(a+b, a-b, a*b)
print(ans)

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

Solution (Python):
A,B = map(int,input().split())
print(max(A+B,A-B,A*B))

Solution (Python):
A, B = (int(x) for x in input().split())
c = A + B
d = A - B
e = A * B

if c <= d:
    if d <= e:
        print(e)
    if d > e:
        print(d)

if c > d:
    if c >= e:
        print(c)
    if c < e:
        print(e)

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

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

num1 = int(i[0])
num2 = int(i[1])

max = num1 + num2

if max < num1 - num2:
	max = num1 - num2
if max < num1 * num2:
	max = num1 * num2

print(max)

Solution (Python):
A,B = map(int,input().split())
a = []
a.append(A+B)
a.append(A-B)
a.append(A*B)
print(max(a))

Solution (Python):
l = list(map(int, input().rstrip().split(" ")))

a = l[0]
b = l[1]
ans = [a+b, a-b, a*b]
print(max(ans))

Solution (Python):
a, b=(int(x) for x in input().split())
print(max(a + b, a - b, a * b))

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

Solution (Python):
A,B = map(int,input().split())
s = A+B
p=A-B
q=A*B

if s >=p:
   if s >=q:
    print (s)
   else:
    print(q)
else:
   if p >=q:
      print (p)
   else: 
       print(q)

Solution (Python):
a,b=map(int,input().split())
print(max([a+b,a-b,a*b]))

Solution (Python):
a, b = list(map(int, input().split()))
print(max(a + b, a - b, a * b))

Solution (Python):


i = list(map(int, input().split()))

a = i[0]
b = i[1]

wa = a + b
sa = a- b
seki = a * b

print(max(wa,sa,seki))

Solution (Python):
l= [int(x) for x in input().split()]
p=[]
p.append(l[0]-l[1])
p.append(l[0]+l[1])
p.append(l[0]*l[1])
print(max(p))

Solution (Python):
ab = [int(i)for i in input().split()]
print(max(ab[0] + ab[1],max(ab[0] * ab[1], ab[0]-ab[1])))

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

tasu = A+B
hiku = A-B
kakeru = A *B

ans =0

if tasu >= hiku and tasu >= kakeru:
  ans = tasu
elif hiku >= tasu and hiku >= kakeru:
  ans = hiku
elif kakeru >= tasu and kakeru >= hiku:
  ans = kakeru

print(ans)

Solution (Python):
import sys

a,b = (int(i) for i in input().split())

s = a + b
h = a - b
m = a * b

l = [s,h,m]
print(max(l))

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

a = [i[0] + i[1], i[0] - i[1], i[0] * i[1]]

MAX = -100000
for x in a:
    if x >= MAX:
        MAX = x

print(MAX)

Solution (Python):
A, B = map(int, input().split())
M = []
kakeru = A*B
tasu = A+B
hiku = A-B
M.append(kakeru)
M.append(tasu)
M.append(hiku)
M.sort(reverse = True)
print(M[0])

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

ans = max(a+b, a-b, a*b)

print(ans)

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

print(max(A+B,A-B,A*B))

Solution (Python):
a, b = map(int, input().split())
plus = a + b
minus = a - b
multi = a * b
if plus >= minus and plus >= multi:
    print(plus)
elif minus >= plus and minus >= multi:
    print(minus)
elif multi >= plus and multi >= minus:
    print(multi)

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

def sum(x, y):
  return x + y

def minus(x, y):
  return x - y

def duplicate(x, y):
  return x * y

ans = [sum(a, b), minus(a, b), duplicate(a, b)]

print(max(ans))

Solution (Python):
A,B = map(int,input().split())
ans = [A+B, A-B, A*B]
print(sorted(ans, reverse=True)[0])

Solution (Python):
A, B = map(int, input().split())
plus = A+B
minus = A-B
mul = A*B

print(max(plus, minus, mul))

Solution (Python):
a, b = map(int, input().split(" "))
print(max([a - b, a + b, a * b]))

Solution (Python):
a, b = map(int, input().split())
plus = a + b
minus = a - b
mult = a * b
ans = max(plus, minus)
ans = max(ans, mult)
print(ans)

Solution (Python):
A,B=map(int,input().split())
ans=max(A+B,A-B)
ans=max(ans,A*B)
print(ans)

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

lists = []
lists.append(A + B)
lists.append(A - B)
lists.append(A * B) 

print(max(lists))

Solution (Python):
A,B = map(int, input().split())
print(max(A+B,A-B,A*B))

Solution (Python):



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

    mx = a + b

    tmp = a - b
    if mx < tmp:
        mx = tmp

    tmp = a * b
    if mx < tmp:
        mx = tmp

    print(mx)

main()

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

result = max([a+b, a-b, a*b])

print(result)

Solution (Python):
N, M = map(int, input().split())

print(max(N+M,N-M,N*M))

Solution (Python):
A,B = map(int,input().split())
print(max(A+B,A-B,A*B))

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

Solution (Python):
param = list(map(int, input().split()))
a = param[0]
b = param[1]
wa = a + b
sa = a - b
seki = a * b
ret = wa if wa > sa else sa
ret = ret if ret > seki else seki
print(ret)

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

Solution (Python):
a,b = [int(x) for x in input().split()]
res = sorted([a+b,a-b,a*b])
print(res[2])

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

sum = A + B
dele = A - B
mul = A * B

print(max(sum, dele, mul))

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

print(max(A+B, A-B, A*B))

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

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

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

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

a1 = A+B
a2 = A-B
a3 = A*B

am = max([a1,a2,a3])

print(am)

Solution (Python):


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


x = [a*b, a+b, a-b]

print(max(x))

Solution (Python):
l = raw_input().split() 
A=int(l[0])
B=int(l[1])

print(max(A+B,A-B,A*B))

Solution (Python):
List = list(map(int,input().split()))
A = List[0]
B = List[1]

wa = A + B
sa = A - B
seki = A * B

if wa < sa:
    if sa <= seki:
        print(seki)
    else:
        print(sa)

if wa >= sa:
    if wa >= seki:
        print(wa)
    else:
        print(seki)

Solution (Python):
a,b=input().split()
a=int(a)
b=int(b)
c=a*b
d=a+b
e=a-b
print(max(c,d,e))

Solution (Python):
def resolve():
    a,b = map(int,input().split())
    print(max(a+b,a-b,a*b))

resolve()

Solution (Python):


import os
import sys

A, B = map(lambda x: int(x), input().split(" "))

print(max(A+B,A-B,A*B))

Solution (Python):


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

print(max(A*B, A+B, A-B))

Solution (Python):
from collections import Counter, defaultdict
import sys
sys.setrecursionlimit(10 ** 5 + 10)

from math import factorial
import heapq, bisect


from math import factorial

def combinations_count(n, r):
    return factorial(n) // (factorial(n - r) * factorial(r))

def main():
    a, b = map(int, input().split())
    ans = max(a + b, a - b, a * b)
    print(ans)




if __name__ == '__main__':
    main()

Solution (Python):
A_B = input()
A = int(A_B.split()[0])
B = int(A_B.split()[1])

ApB = A + B
AmB = A - B
AbB = A*B

nums = [ApB, AmB, AbB]

nums.sort(reverse=True)

print(nums[0])

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

Solution (Python):
A,B = input().split()
a = int(A)
b = int(B)
seki = a*b
wa = a+b
sa = a-b
if seki >= wa and seki >= sa:
    print(seki)
elif wa >= seki and wa>= sa:
    print(wa)
else:
    print(sa)

Solution (Python):

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

intt_array = [0] * 3
intt_array[0] = a + b
intt_array[1] = a - b
intt_array[2] = a * b


intt_array.sort(reverse=True)
print(intt_array[0])

Solution (Python):
A,B=(input().split(' '))
A=int(A)
B=int(B)
AplusB=A+B
AminusB=A-B
AmultiplyB=A*B
ans=AplusB if AplusB>AminusB else AminusB
ans=ans if ans>AmultiplyB else AmultiplyB
print(ans)

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

Solution (Python):
a, b = map(int, input().split())
print(max([a+b, a-b, a*b]))

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

ab_sum = a + b
ab_dif = a - b
ab_mul = a * b

print(max([ab_sum, ab_dif, ab_mul]))

Solution (Python):
firstline=input().split()
A=int(firstline[0])
B=int(firstline[1])
print(max(A+B,A-B,A*B))

Solution (Python):

a, b = list(map(int, input().split()))
m = -200000
if m < a + b:
    m = a+b
if m < a - b:
    m = a-b
if m < a*b:
    m = a*b

print(m)

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

add = a + b
sub = a - b
mul = a * b

cal = [add,sub,mul]
print(max(cal))

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

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

print(max(a*b,a+b,a-b))

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

print(max(A+B, A-B, A*B))

Solution (Python):
a,b=map(int, input().split()) 
wa = a+b
sa = a-b
seki = a*b
print(max(wa,sa,seki))

Solution (Python):
A,B = map(int, input().split())
print(max([A+B,A-B,A*B]))

Solution (Python):
a,b=(int(x) for x in input().split())
sum=a+b
minus=a-b
kakeru=a*b

if sum>=minus and sum>=kakeru:
  print(sum)
elif minus>=sum and minus>=kakeru:
  print(minus)
elif kakeru>=sum and kakeru>=minus:
  print(kakeru)

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

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

Solution (Python):
A,B = map(int,input().split())
tmp = A+B if B>0 else A-B
tmp = A*B if A*B > tmp else tmp
print(tmp)

Solution (Python):
def main():
    a, b = map(int,input().split())
    plus = a + b
    times = a * b
    minus = a - b
    print(max(plus, times, minus))
    
main()

Solution (Python):
lines = input().split(" ")
A = int(lines[0])
B = int(lines[1])
arr = []

arr.append(A + B)
arr.append(A - B)
arr.append(A * B)

print(max(arr))

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

print(max(a+b, a-b, a*b))

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

res = max(a + b,a - b,a * b)

print(res)

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

Ans1=A+B
Ans2=A-B
Ans3=A*B


print(max(Ans1,Ans2,Ans3))

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

print(max(a + b, a - b, a * b))

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

print(max(a+b,a-b,a*b))

Solution (Python):
A,B = map(int,input().split())
print(max(A+B,A-B,A*B))

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

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

x = a - b
y = a + b
z = a * b

print(max(x,y,z))

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

a = A + B
b = A - B
c = A * B



l = [a, b, c]

print(max(l))

Solution (Python):
li = list(map(int,input().split()))
a = li[0]
b = li[1]
lists = [a+b,a*b,a-b]
print(max(lists))

Solution (Python):
lines = input().split(" ")
A = int(lines[0])
B = int(lines[1])
arr = []

arr.append(A + B)
arr.append(A - B)
arr.append(A * B)

print(max(arr))

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

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

n = int(a[0])
m = int(a[1])

l = [0, 0, 0]
l[0] = n + m
l[1] = n - m
l[2] = n * m

print(max(l))

Solution (Python):
import numpy as np
n1, n2=input().split(' ')
n1 = int(n1)
n2 = int(n2)
a = np.array([n1 + n2, n1 - n2, n1 * n2])
print(a.max())

Solution (Python):
a , b  = map(int,input().split())
add = a + b
sub = a - b
mul = a * b
if add >= sub and add >= mul:
	max = add
elif sub >= add and sub >= mul:
  	max = sub
else:
    max = mul
print(max)

Solution (Python):

a, b = map(int, input().split())
calc_results = [a+b, a-b, a*b]
print(max(calc_results))

Solution (Python):
import numpy as np

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

print(np.max([A+B, A-B, A*B]))

Solution (Python):
i= input().split()
j=int(i[0])
k=int(i[1])

print(max(j+k,j-k,j*k))

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

Solution (Python):
A, B = map(int, input().split())
print(max(A+B, A-B, A*B))

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

max = A + B
hiku = A - B
kake = A * B

if max < hiku:
    max = hiku

if max < kake:
    max = kake

print(max)

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

def hantei(A, B):
    tasu = A + B
    hiku = A - B
    kake = A * B
    if tasu >= hiku:
        if tasu >= kake:
            return(tasu)
        else:
            return(kake)
    else:
        if hiku >= kake:
            return(hiku)
        else:
            return(kake)
print(hantei(A,B))

Solution (Python):



def main():
    a, b = map(int, input().split())
    print(max(a + b, a - b, a * b))


if __name__ == '__main__':
    main()

Solution (Python):
a, b = list(map(int, input().split()))
print(max(a+b, a-b, a*b))

Solution (Python):
a = list(map(int, input().split(" ")))
A=a[0]
B=a[1]

if A+B>=A-B and A+B>=A*B:
	print(A+B)
elif A-B>=A+B and A-B>=A*B:
	print(A-B)
else:
	print(A*B)

Solution (Python):
A,B=map(int,input().split())
x=[A+B,A*B,A-B]
print(max(x))

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

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

print(max(a+b,a-b,a*b))

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

Solution (Python):
A, B = map(int,input().split())
a = A + B
b = A - B
c = A * B
if a >= b:
    if a >= c:
        print(a)
    else:
        print(c)
elif b >= c:
    print(b)
else:
    print(c)

Solution (Python):
i= input().split()
j=int(i[0])
k=int(i[1])

print(max(j+k,j-k,j*k))

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

print(max(A+B, A-B, A*B))

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

Solution (Python):
A, B = map(int, input().split())
a = A + B
b = A - B
c = A * B
print(max(a,b,c))

Solution (Python):
a,b=map(int,input().split())
X = int(a + b)
Y = int(a - b)
Z = int(a * b)
ans = [X,Y,Z]
print(max(ans))

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

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

print(max(a*b,a-b,a+b))

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

Solution (Python):
a, b = map(int, input().split())
print(max([a + b, a - b, a * b]))

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

if num < A - B:
    num = A - B

if num < A * B:
    num = A * B

print(num)

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


c1=a+b
c2=a-b
c3=a*b

if c1>=c2 and c1>=c3:
    print(c1)

elif c2>=c1 and c2>=c3:
    print(c2)
else:
    print(c3)

Solution (Python):
A,B = map(int,input().split())
print(max(A*B,A+B,A-B))

Solution (Python):
A,B = map(int,input().split())
tasu=A+B
hiku=A-B
kake=A*B
if tasu>=hiku and tasu>=kake:
  print(tasu)
elif hiku>=tasu and hiku>=kake:
  print(hiku)
else:
  print(kake)

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

a = int(lis[0]) + int(lis[1])
b = int(lis[0]) - int(lis[1])
c = int(lis[0]) * int(lis[1])

if a > b:
    m = a
    if m > c:
        pass
    else:
        m = c
else:
    m = b
    if b > c:
        pass
    else:
        m = c
        
print(m)

Solution (Python):
import os
import sys

A,B = map(int,input().split())
print(max([A+B, A-B, A*B]))

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

c=a+b
d=a-b
e=a*b

print(max(c,d,e))

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

A,B=map(int,input().split())
print(max(A+B,A-B,A*B))

Solution (Python):

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

k1 = a + b
k2 = a - b
k3 = a * b

if k1 > k2 :
    if k1 > k3 :
        print(k1)
    else :
        print(k3)
elif k2 > k3:
        print(k2)
else :
        print(k3)

Solution (Python):

a,b=map(int, input().split())
 
x = a+b
y = a-b
z = a*b
 
if x>=y and x>=z:
    print(x)
    
elif y>=x and y>=z:
    print(y)   
    
elif z>=x and z>=y:
    print(z)

Solution (Python):

L = map(int, raw_input().split())
A = L[0]
B = L[1]

print max (A + B, A-B, A*B)

Solution (Python):
import numpy as np

A,B=input().split()

array=np.zeros((3))

array[0]=int(A)+int(B)
array[1]=int(A)-int(B)
array[2]=int(A)*int(B)

print(int(np.max(array)))

Solution (Python):
a, b = map(int, raw_input().split())
print max(a + b, a - b, a * b)

Solution (Python):
a,b = list(map(int,input().split()))
add = a+b
div = a-b
mlt = a*b
if add >= div and add>= mlt:
  print(add)
elif div >= add and div >= mlt:
  print(div)
elif mlt >= add and mlt >= div:
  print(mlt)

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

Solution (Python):


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

sum = a + b
sub = a - b
kake = a * b

print(max(sum, sub, kake))

Solution (Python):
A, B = map(int, input().split())
lis = [A+B,A-B,A*B]
print(max(lis))

Solution (Python):
a = [ int(x) for x in input().split()]

p = a[0] + a[1]
m = a[0] - a[1]
b = a[0] * a[1]

print(max(p, max(m, b)))

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

Solution (Python):
A,B = (int(i) for i in input().split())
X = []

X.append(A + B)
X.append(A - B)
X.append(A * B)

X.sort()
print(X[2])

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

num_list = []
sum_num = a + b
num_list.append(sum_num)
minus_num = a - b
num_list.append(minus_num)
multi_num = a * b
num_list.append(multi_num)

print(max(num_list))

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

print(max(A + B, A - B, A * B))

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

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

ret = max(a+b, a-b, a*b)
print(ret)

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

if a+b > a-b:
  if a+b > a*b:
    print(a+b)
  else:
    print(a*b)
    
else:
  if a-b > a*b:
    print(a-b)
  else:
    print(a*b)

Solution (Python):
a=input().split(" ")
A=int(a[0])
B=int(a[1])
p=A+B
q=A-B
r=A*B
if p>=q:
    s=p-r
    if s>=0:
        print(p)
    else:
        print(r)
if q>p:
    s=q-r
    if s>=0:
        print(q)
    else:
        print(r)

Solution (Python):
A,B=map(int,input().split())
print(max(A+B,A-B,A*B))

Solution (Python):

"""
Created on Sat Aug 10 20:59:09 2019

@author: doppe
"""

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

max = A + B
if (max < A- B):
    max = A - B
if (max < A * B):
    max = A * B

print(max)

Solution (Python):
A, B = list(map(int, input().split()))
plus = A + B
minus = A - B
times = A * B
results = [plus, minus, times]
max_val = -float('inf')
for r in results:
  if r > max_val:
    max_val = r
print(max_val)

Solution (Python):
A, B = map(int, input().split())
ma = 0
if (A + B) > (A - B):
  max = A + B
else:
  max = A - B
  
if (A * B) > max:
  print(A * B)
else:
  print(max)

Solution (Python):
A, B = map(int, input().split())
print(max(A+B, max(A-B, A*B)))

Solution (Python):
A, B = map(int, input().split())
print(max([A+B, A-B, A*B]))

Solution (Python):
A, B = map(int, input().split()) 
sum1 = A + B
sum2 = A - B
sum3 = A * B

print(max([sum1, sum2, sum3]))

Solution (Python):
a, b = map(int, input().split())
x = a+b
y = a-b
z = a*b
print(max(x,y,z))

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

c=a+b
d=a-b
e=a*b

if c>d:
	if c>e:
		print(c)
	else:
		print(e)
else:
	if d>e:
		print(d)
	else:
		print(e)

Solution (Python):
x,y = map(int,input().split())

a=x+y
b=x-y
c=x*y

print(max(a,b,c))

Solution (Python):
a,b = map(int,input().split(" "))
plus = a+b
sub = a-b
mul = a*b
max = plus if plus>sub else sub
max = mul if mul>max else max
print(max)

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

print(max(A+B,A-B,A*B))

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

if a >= b and a >= c:
    print(a)
elif b >= a and b >= c:
    print(b)
else :
    print(c)

Solution (Python):
A,B = map(int,input().split())
print(max([A+B,A-B,A*B]))

Solution (Python):
import numpy as np

a, b = map(int, input().split())
print(np.max([a + b, a - b, a * b]))

Solution (Python):

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

x=A+B
y=A-B
z=A*B

if x>y and x>z:
    print(x)
elif z>y and z>x:
    print(z)
else:
    print(y)

Solution (Python):
x, y = map(int, input().split())

a = x + y
b = x - y
c = x * y

if a > b:
    if a > c:
        print(a)
    else:
        print(c)
else:
    if b > c:
        print(b)
    else:
        print(c)

Solution (Python):
a, b = map(int, input().split())
plu = a + b
dis = a - b
multi = a * b

print(max(plu, dis, multi))

Solution (Python):
a, b = map(int, input().split())
c = a - b
d = a + b
e = a * b
print(max(c, d, e))

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

print(max(A+B, A-B, A*B))

Solution (Python):
A,B=map(int,input().split())
print(max(A+B,A-B,A*B))

Solution (Python):
import numpy as np
a = [int(i) for i in input().split()] 

print(np.array([a[0]+a[1],a[0]-a[1],a[0]*a[1]]).max())

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

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

li=[n*m,n+m,n-m]
print(max(li))

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

Solution (Python):
a, b = map(int, input().split())
c = a + b
d = a - b
e = a*b
print(max([c, d, e]))

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

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

Solution (Python):
A,B=map(int, input().split())
print(max(max(A+B,A-B),A*B))

Solution (Python):

A, B = map(int, input().split())
print(max(A + B, A - B, A * B))

Solution (Python):
(A, B) = map(int, input().split())
x = A+B
y = A-B
z = A*B
ans = [x, y, z]
print(max(ans))

Solution (Python):
a,b = map(int,input().split())
print(max([a+b,a-b,a*b]))

Solution (Python):
a, b = map(int, input().split())
c1 = a + b
c2 = a - b
c3 = a * b
print(max(c1, c2, c3))

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

kakeru=a*b
minus=a-b
plus=a+b


if kakeru > minus:
    grater=kakeru
else:
    grater=minus

if grater > plus:
    max=grater
else:
    max=plus

print(max)

Solution (Python):
A,B = map(int,input().split())
print(max(A*B,A+B,A-B))

Solution (Python):
import sys

input = sys.stdin.readline


def main():
    a, b = [int(i) for i in input().split()]
    print(max([a + b, a - b, a * b]))


if __name__ == "__main__":
    main()

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

sum = a + b
sub = a - b
multi = a* b

x = [sum, sub, multi]

print(max(x))

Solution (Python):
A, B   = map(int, input().split())
x= A+B
y= A-B
z=A*B
print(max([x,y,z]))

Solution (Python):
a,b=map(int,input().split())
by=a*b
plus=a+b
mi=a-b
print(max(by,plus,mi))

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

print(max(A+B, A-B, A*B))

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

plus = a + b
minus1 = a - b
kake = a * b

result = max(plus, minus1, kake)

print(result)

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

print(max(A+B,A-B,A*B))

Solution (Python):




 
from collections import* 
from fractions import gcd
from functools import* 
from itertools import* 
from operator import mul,itemgetter
from bisect import* 
from heapq import* 
from math import factorial,pi
from copy import deepcopy
import sys
sys.setrecursionlimit(10**8)

 
def main():
    a,b=map(int,input().split())
    print(max(a+b,a-b,a*b))
                    
        
if __name__ == '__main__':
    main()

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

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

print(max(a+b, a-b, a*b))

Solution (Python):
x, y = map(int, input().split())
a = int(x + y)
b = int(x - y)
c = int(x * y)
l = [a, b, c]
print(max(l))

Solution (Python):
X = input().split()
A = int(X[0])
B = int(X[1])

ans = -999999999

a = []

a.append(A+B)
a.append(A-B)
a.append(A*B)

add = A+B
sub = A-B
mul = A*B

if add > ans:
    ans = add

if sub > ans:
    ans =sub

if mul > ans:
    ans = mul

print(ans)

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

sum = a + b
diff = a - b
mul = a * b
ans = sum

if sum > diff:
    ans = sum
else:
    ans = diff

if ans > mul:
    print(ans)
else:
    print(mul)

Solution (Python):
a, b = map(int, input("").split())
print (max([a + b, a - b, a * b]))

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

tmp1 = a + b
tmp2 = a - b
tmp3 = a*b

m = tmp1
if m < tmp2:
  m = tmp2
if m < tmp3:
  m = tmp3

print(m)

Solution (Python):
str = input()

A = (int(str.split()[0]))
B = (int(str.split()[1]))

X = A + B
Y = A - B
Z = A * B
E = 0
if (X < Y) :
	if (Y < Z) :
		E = Z
	else :
		E = Y
else :
	if (X < Z) :
		E = Z
	else :
		E = X
print("{}".format(E))

Solution (Python):
A, B = map(int, input().split())
print(max(A+B, A-B, A*B))

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

c=[]
c.append(a+b)
c.append(a-b)
c.append(a*b)

print(max(c))

Solution (Python):
A,B= map(int,input().split())
x=A+B
y=A-B
z=A*B
s=[x,y,z]
s.sort()
print(s[2])

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

print(max(a+b, a-b, a*b))

Solution (Python):
tmp = input().split()
a = int(tmp[0])
b = int(tmp[1])
array = [a + b, a - b, a * b]
print(max(array))

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

kouho = []
kouho.append(a + b)
kouho.append(a - b)
kouho.append(a * b)
print(max(kouho))

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

print(max(a+b,max(a-b,a*b)))

Solution (Python):
import math
a, b= map(int, input().split())
s = max([a+b, a-b, a*b])
print(s)

Solution (Python):
A,B = list(map(int,input().split()))
print(max(A+B,A-B,A*B))

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

print( max( a+b, a-b, a*b ) )

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

apb = a+b
amb = a-b
akb = a*b

if apb > amb:
    if apb > akb:
        print(apb)
    else:
        print(akb)
else:
    if amb > akb:
        print(amb)
    else:
        print(akb)

Solution (Python):
A, B = map(int,input().split())
print(str(max(A+B, A-B, A*B)))

Solution (Python):
a, b = map(int, input().split())
ls = [a + b, a - b, a * b]
ls.sort()
print(ls[2])

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

plus =  A + B
minus = A - B
mult =  A * B

a_list = []
a_list.append(plus)
a_list.append(minus)
a_list.append(mult)

print(max(a_list))

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

max_num = - float('inf')

if A + B > max_num:
    max_num = A + B

if A - B > max_num:
    max_num = A - B

if A * B > max_num:
    max_num = A * B

print(max_num)