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):
from sys import stdin

readline = stdin.readline


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


if __name__ == "__main__":
    main()

Solution (Python):
A, B = [int(_) for _ in 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=[int(i) for i in input().split()]
print(max([A+B,A-B,A*B]))

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

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

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


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


print(ans)

Solution (Python):

a, b = map(int, input().split())
ans = max([a+b, a*b, a-b])
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())
ans = max(a+b, a-b, a*b)
print(ans)

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

Solution (Python):
from subprocess import*
with open('A.py','w')as f:
    f.write('a,b=map(int,input().split())\n')
    for i in range(-100,101):
        f.write('if a==%d:\n'%i)
        for j in range(-100,101):
            f.write('    if b==%d:print(%d)\n'%(j,max(i+j,i-j,i*j)))
call(('python3','A.py'))

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

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())
ans = [a+b, a-b, a*b]
print(max(ans))

Solution (Python):
while True:
    try:
        A, B = map(int, input().split())
        print(max(A + B, A - B, A * B))
    except EOFError:
        break

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

Solution (Python):
import bisect;import heapq;import itertools;import math;import operator;import os;import re;import string;import sys;from collections import Counter, deque, defaultdict;from copy import deepcopy;from decimal import Decimal;from fractions import gcd;from functools import lru_cache, reduce;from operator import itemgetter, mul, add, xor;import numpy as np;sys.setrecursionlimit(2147483647);INF = float("inf");IINF = 10 ** 18;MOD = 10 ** 9 + 7



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,a-b,a*b))

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())
pls=(a)+(b)
mns=(a)-(b)
kak=(a)*(b)
if kak>=pls and kak>=mns:
    print(kak)
elif pls>=mns and pls>=kak:
    print(pls)
elif mns>=pls and mns>=kak:
    print(mns)

Solution (Python):
sp = " ";rt = "\n";MOD = 1e9+7
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):
sp = " ";rt = "\n";MOD = 1e9+7
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()))
ans = max(a + b, a - b, a * b)
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())

P = A + B
M = A - B
T = A * B

print(max(P, M, T))

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

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

Solution (Python):
import sys



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

raw_input = sys.stdin.readline

if __name__ == '__main__':
	
	main()

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

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

Solution (Python):
a,b=list(map(int,input().strip().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
print(max(x,y,z))

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 = [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())
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):
inpl = lambda: list(map(int,input().split()))
A, B = inpl()
print(max(A+B,A-B,A*B))

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

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

max_num = a + b
for i in [a*b, a-b]:
    if i > max_num:
        max_num = i
print(max_num)

Solution (Python):
a, b = map(int, input().split())
ans1 = a + b
ans2 = a - b
ans3 = a * b
if ans1 >= ans2 and ans1 >= ans3:
  print(ans1)
  exit()
if ans2 >= ans1 and ans2 >= ans3:
  print(ans2)
  exit()
if ans3 >= ans1 and ans3 >= ans2:
  print(ans3)
  exit()

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())
  c = max(a*b, a+b, a-b)
  print(c)


if __name__ == '__main__':
  main()

Solution (Python):



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

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

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

m = a+b
if a-b > m:
    m = a-b
if a*b > m:
    m = a*b

print(m)

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())
 
t = A + B
x = A * B
m = A - B
 
map = {'t': t, 'x': x, 'm': m}

sorted_map = sorted(map.items(), key=lambda x:x[1])

ans = sorted_map[-1]
print(ans[-1])

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

if c>=d and c>=e:
    print(c)
elif d>=c and d>=e:
    print(d)
elif e>=c and e>=d:
    print(e)

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

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

print(max(list))

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

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

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

sum = A+B
difference = A-B
product = A*B

ans = sum

if ans < difference:
    ans = difference

if ans < product:
    ans = product

print(ans)

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

ans = max(A + B, A - B, A * B)

print('{}'.format(ans))

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

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

Solution (Python):
a, b = map(int, input().split())
 
plus = a + b
 
minus = a - b
 
kakeru = a * b

list = [plus, minus, kakeru]

print(max(list))

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

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()
 
A,B = MULT_INT_LIST()
new = []
C = A+B 
D = A-B
E = A*B
new.append(C)
new.append(D)
new.append(E)
print(max(new))

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

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()
 
A,B = MULT_INT_LIST()
new = []
C = A+B 
D = A-B
E = A*B
new.append(C)
new.append(D)
new.append(E)
print(max(new))

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

def SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()
 
A,B = MULT_INT_LIST()
new = []
C = A+B 
D = A-B
E = A*B
new.append(C)
new.append(D)
new.append(E)
print(max(new))

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())
lst = []
lst.append(A+B)
lst.append(A-B)
lst.append(A*B)
print(max(lst))

Solution (Python):

A,B = map(int,input().split())
ans1 = A+B
ans2 = A*B
ans3 = A-B

print(max(ans1,ans2,ans3))

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

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

anser = add

if anser < dif:
  anser = dif

if anser < mul:
  anser = mul

print(anser)

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

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

n_list = []
c = a + b
d = a - b
e = a * b

n_list.append(c)
n_list.append(d)
n_list.append(e)

print(max(n_list))

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

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())
print(max(A+B,A-B,A*B))

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

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

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

d = a+b
e = a-b
f = a*b
print(max(max(d,e),f))

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):
mi = lambda: map(int, input().split())
add = lambda x, y: x + y
sub = lambda x, y: x - y
mul = lambda x, y: x * y

A, B = mi()
l = [add(A, B), sub(A, B), mul(A, B)]
print(max(l))

Solution (Python):
a,b=map(int,input().split())
print((((str(a-b)),str(a+b))[a+b>a-b],str(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):
l=input().split()
a=int(l[0])+int(l[1])
b=int(l[0])-int(l[1])
c=int(l[0])*int(l[1])
print(max(a,b,c))

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

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

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 = input().split()
a = int(_ab[0])
b = int(_ab[1])

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

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

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

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

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

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

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

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

Solution (Python):



def main():
    a,b = [int(i) for i in input().split(' ')]

    one = a + b
    two = a - b
    three =a * b

    print(max(one ,two ,three))

if __name__ == "__main__":
    main()

Solution (Python):
input_list = input().split()
A = int(input_list[0])
B = int(input_list[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)
elif (A+B) <= (A-B) and (A+B) >= (A*B):
    print(A-B)
elif (A+B) <= (A-B) and (A+B) <= (A*B):
    if (A-B) >= (A*B):
        print(A-B)
    else:
        print(A*B)

Solution (Python):
i=list(map(int,input().split()))
C=i[0]+i[1]
D=i[0]-i[1]
E=i[0]*i[1]

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, raw_input().split())
print max([A+B,A-B,A*B])

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

Solution (Python):

import sys


def solve(A: int, B: int):

    res = A + B
    if res < A - B:
        res = A - B
    if res < A * B:
        res = A * B

    print(res)


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(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, B = map(int, input().split())
print(max(A + B, A - B, A * B))

Solution (Python):

ab=list(map(int,input().split()))
a=ab[0]+ab[1]
b=ab[0]*ab[1]
c=ab[0]-ab[1]
flag=0
if a>b:
  if a>c:
    print(a)
    flag=1
else:
  if b>c:
    print(b)
    flag=1
if flag==0:
  print(c)

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()))
C = [A + B, A - B, A * B]
print(max(C))

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

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

print(maxi)

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

Solution (Python):
A, B = list(map(int, input().strip().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())
print(max(A-B, A+B, A*B))

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

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):
args = input().split()
A = int(args[0])
B = int(args[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 = list(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, max(a-b, a*b)))

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 SORO_INT(): return int(INPUT())
def MULT_INT_LIST(): return list(map(int, INPUT().split()))
def MULT_INT_MAP(): return map(int, INPUT().split())
def SORO_STRING(): return INPUT()
def MULT_STRING(): return INPUT().split()

A,B = MULT_INT_LIST()
new = []
C = A+B 
D = A-B
E = A*B
new.append(C)
new.append(D)
new.append(E)
print(max(new))

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

ans = a + b

if ans < (a-b):
  ans = a - b

if ans < (a*b):
  ans = a * b


print(ans)

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

nAns = A+B
nTmp = A-B

if nTmp > nAns:
  nAns = nTmp

nTmp = A*B

if nTmp > nAns:
  nAns = nTmp

print(nAns)

Solution (Python):
import sys

def main():
    input = sys.stdin.readline
    A, P = map(int, input().split())
    s = A + P
    d = A - P
    f = A * P
    num_list = [s, d, f]
    
    return max(num_list)

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

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

Solution (Python):
A,B=[int(a) for a in str(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())
plus = A+B
minus = A-B
times = A*B
print(max(plus, minus, times))

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

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

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

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

a=int[0]
b=int[1]

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

max=x
if y > max:
    max=y
if z > max:
    max=z
print(max)

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

Solution (Python):
a = list(map(int,input().split()))
pla = a[0] + a[1]
mai = a[0] - a[1]
mul = a[0] * a[1]
ans = [0,0,0]
ans[0] = pla
ans[1] = mai
ans[2] = mul
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())
ans = max(a+b, a-b)
ans = max(ans, a*b)
print(ans)

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

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

max = -100

if A*B > max:
  max = A*B
if A+B > max:
  max = A+B
if A-B > max:
  max = A-B
  
print(max)

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

A = S[0]
B = S[1]

list = []

C = A-B
list.append(C)
D = A+B 
list.append(D)
E = A*B
list.append(E)

print(max(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())
ans= []
ans.append(a+b)
ans.append(a-b)
ans.append(a*b)

print(max(ans))

Solution (Python):
A,B=[int(item) for item 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):
str = input()
numbers = str.split(" ")

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

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

print(max([sum, diff, kake]))

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

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):
def A_pluminus():
    A, B = map(int, input().split())
    plus = A + B
    minus = A - B
    kakeru = A * B
    list_a  = [plus, minus, kakeru]
    print(max(list_a))
    
if __name__ == "__main__":
    A_pluminus()

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

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

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

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

Solution (Python):
def main(text):
    a = list(map(int, text.split()))
    print(max([a[0]+a[1], a[0]-a[1], a[0]*a[1]]))


main(input())

Solution (Python):
from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations
import sys
import bisect
import string
sys.setrecursionlimit(10**6)
def SI():
    return input().split()
def MI():
    return map(int,input().split())
def I():
    return int(input())
def LI():
    return [int(i) for i in input().split()]
YN=['Yes','No']
YNeos='YNeos'
mo=10**9+7
imp='IMPOSSIBLE'

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

Solution (Python):





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



if (A + B) > (A - B):
	MAX = (A + B)
else:
	MAX = (A - B)

if MAX > (A * B):
	print(MAX)
else:
	print(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):
import numpy as np

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

ans = np.zeros(3)
ans[0] = A + B
ans[1] = A - B
ans[2] = A * B

print(int(np.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(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):
import sys

for line in sys.stdin:
  [a,b] = map(lambda x:int(x),line.split(' '))
  print(sorted([a+b,a-b,a*b])[2])

Solution (Python):

import sys






"""Template"""


class IP:
    """
    入力を取得するクラス
    """

    def __init__(self):
        self.input = sys.stdin.readline

    def I(self):
        """
        1文字の取得に使います
        :return: int
        """
        return int(self.input())

    def S(self):
        """
        1文字の取得(str
        :return: str
        """
        return self.input()

    def IL(self):
        """
        1行を空白で区切りリストにします(int
        :return: リスト
        """
        return list(map(int, self.input().split()))

    def SL(self):
        """
        1行の文字列を空白区切りでリストにします
        :return: リスト
        """
        return list(map(str, self.input().split()))

    def ILS(self, n):
        """
        1列丸々取得します(int
        :param n: 行数
        :return: リスト
        """
        return [int(self.input()) for _ in range(n)]

    def SLS(self, n):
        """
        1列丸々取得します（str
        :param n: 行数
        :return: リスト
        """
        return [self.input() for _ in range(n)]

    def SILS(self, n):
        """
        Some Int LineS
        横に複数、縦にも複数
        :param n: 行数
        :return: list
        """
        return [self.IL() for _ in range(n)]

    def SSLS(self, n):
        """
        Some String LineS
        :param n: 行数
        :return: list
        """
        return [self.SL() for _ in range(n)]


class Idea:
    def __init__(self):
        pass

    def HF(self, p):
        """
        Half enumeration
        半分全列挙です
        pの要素の和の組み合わせを作ります。
        ソート、重複削除行います
        :param p: list : 元となるリスト
        :return: list : 組み合わせられた和のリスト
        """
        return sorted(set(p[i] + p[j] for i in range(len(p)) for j in range(i, len(p))))

    def Bfs2(self, a):
        """
        bit_full_search2
        bit全探索の改良版
        全探索させたら2進数のリストと10進数のリストを返す
        :return: list２つ : １個目 2進数(16桁)  2個目 10進数
        """
        
        
        
        value = []
        for i in range(1 << len(a)):
            output = []

            for j in range(len(a)):
                if self.bit_o(i, j):
                    """右からj+1番目のiが1かどうか判定"""
                    
                    output.append(a[j])
            value.append([format(i, 'b').zfill(16), sum(output)])

        value.sort(key=lambda x: x[1])
        bin = [value[k][0] for k in range(len(value))]
        val = [value[k][1] for k in range(len(value))]
        return bin, val

    def S(self, s, r=0, m=-1):
        """
        ソート関係行います。色々な設定あります。
        :param s: 元となるリスト
        :param r: reversするかどうか 0=False 1=True
        :param m: （2次元配列）何番目のインデックスのソートなのか
        :return: None
        """
        r = bool(r)
        if m == -1:
            s.sort(reverse=r)
        else:
            s.sort(reverse=r, key=lambda x: x[m])

    def bit_n(self, a, b):
        """
        bit探索で使います。0以上のときにTrue出します
        自然数だからn
        :param a: int
        :param b: int
        :return: bool
        """
        return bool((a >> b & 1) > 0)

    def bit_o(self, a, b):
        """
        bit探索で使います。1のときにTrue出すよ
        oneで1
        :param a: int
        :param b: int
        :return: bool
        """
        return bool(((a >> b) & 1) == 1)

    def ceil(self, x, y):
        """
        Round up
        小数点切り上げ割り算
        :param x: int
        :param y: int
        :return: int
        """
        return -(-x // y)

    def ave(self, a):
        """
        平均を求めます
        :param a: list
        :return: int
        """
        return sum(a) / len(a)

    def gcd(self, x, y):
        if y == 0:
            return x
        else:
            return self.gcd(y, x % y)

    def lcm(self, x, y):
        return (x * y) // self.gcd(x, y)


"""ここからメインコード"""


def main():
    
    r, e = range, enumerate
    ip = IP()
    id = Idea()

    """この下から書いてね"""
    a, b = ip.IL()
    memo = max(a+b, a-b)
    print(max(memo, a*b))


main()

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

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

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

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

arr = [x, y, z]
result = sorted(arr)
print(result[2])

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

Solution (Python):


import re
from collections import deque
from functools import reduce
from itertools import permutations
from math import pi
from operator import itemgetter
from operator import mul
from operator import xor
from os import linesep
from queue import PriorityQueue
from sys import stdin


def rline() -> str:
    return stdin.readline().strip()


def rlines(hint: int = 1):
    ret = ['' for i in range(hint)]
    for i in range(hint):
        ret[i] = rline()
    return ret


def htokens(hint: int = 1):
    lns = rlines(hint)
    ret = list(map(lambda ln: ln.split(), lns))
    
    if hint == 1:
        
        ret.append([])
    return ret


def vtokens(hint: int = 1):
    m, _ = htokens()
    wint = len(m)
    ret = [[None] * hint for i in range(wint)]
    for y in range(hint):
        if y != 0:
            m, _ = htokens()
        
        x = 0
        for v in m:
            ret[x][y] = v
            x += 1
    
    if wint == 1:
        
        ret.append([])
    return ret


def rint(radix: int = 10) -> int:
    return int(rline(), radix)


def hints(hint: int = 1, radix: int = 10):
    ret = htokens(hint)
    for i in range(len(ret)):
        ret[i] = list(map(lambda v: int(v, radix), ret[i]))
    return ret


def vints(hint: int = 1, radix: int = 10):
    ret = vtokens(hint)
    for i in range(len(ret)):
        ret[i] = list(map(lambda v: int(v, radix), ret[i]))
    return ret


def mat(hint: int, wint: int):
    return [[None]*wint for i in range(hint)]


def filllist(lst, value: int) -> None:
    
    for i in range(len(lst)):
        lst[i] = value


def isprime(n: int) -> bool:
    if n <= 1:
        return False
    if n in (2, 3, 5):
        return True
    if n % 2 == 0:
        return False
    if n % 3 == 0:
        return False
    lst = int(n**0.5)
    f = 5
    while f <= lst:
        if n % f == 0:
            return False
        if n % (f + 2) == 0:
            return False
        f += 6
    return True


def strmat(matrix, lnsep: str = linesep, fieldsep: str = ' ') -> str:
    return lnsep.join(map(lambda row: fieldsep.join(map(str, row)), matrix))


def strbool(boolval: int) -> str:
    return ['No', 'Yes'][boolval]


def solve() -> None:
    
    (a, b), _ = hints()

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

    
    print(ans)


if __name__ == '__main__':
    solve()

Solution (Python):
a,b = map(int,input().split())
p = a+b
m = a-b
k = a*b
l =[p,m,k]
l.sort(reverse=True)
print(l[0])

Solution (Python):
inp = input().split(" ")
map(int, inp)
inp[0] = int(inp[0])
inp[1] = int(inp[1])
p = inp[0] + inp[1]
m = inp[0] - inp[1]
x = inp[0] * inp[1]
pmx = []
pmx.append(p)
pmx.append(m)
pmx.append(x)
print(max(pmx))

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

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

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

x = max([A+B, A-B, A*B])

print(x)

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

Solution (Python):
a, b = [int(ii) for ii 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):
from sys import stdin

def main():
    a, b = [int(x) for x in stdin.readline().rstrip().split()]

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

if __name__ == '__main__':
    main()

Solution (Python):



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

A = input[0]
B = input[1]

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):
input_data = input().split()
a = int(input_data[0])
b = int(input_data[1])

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

print(max(num_list))

Solution (Python):

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

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

Solution (Python):
i = list(map(int, input().split()))
l = [i[0] + i[1], i[0] - i[1], i[0]*i[1]]
print(max(l, key=int))

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

import numpy as np

a,b=acinput()


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

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

ans1 = a + b
ans2 = a - b
ans3 = a * b

ans = [ans1, ans2, ans3]

ans.sort(reverse=True)

print(ans[0])

Solution (Python):


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

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

Solution (Python):
a, b = map(int, input().split())
c = a + b
d = a - b
e = a * b
if(c < e and d < e):
    print(e)
elif(c < d and e < d):
    print(d)
else:
    print(c)

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

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

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

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

if __name__ == "__main__":
    main()

Solution (Python):
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**9)
 
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()

a,b = na()

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

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

m = a - b
p = a + b
f = a * b

print(max(m, max(p, f)))