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 = 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]
def max(x,y,z):
  if x>y:
    m=x
  else:
    m=y
  if z>m:
    m=z
  return m
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())
print(max(a+b, a-b, a*b))

Solution (Python):
a=input().split(" ")
A,B=int(a[0]),int(a[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=input().split()
a=int(A)
b=int(B)
s=a+b
t=a-b
u=a*b
x=max(s,t,u)
print(x)

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

s = A+B
p=A-B
q =A*B

print(max(s,p,q))

Solution (Python):
from sys import stdin, setrecursionlimit
setrecursionlimit(10000000)

input = stdin.readline
lmi = lambda: list(map(int, input().split()))
mi = lambda: map(int, input().split())
si = lambda: input().strip('\n')
ssi = lambda: input().strip('\n').split()


a, b = mi()
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
S = [A,B,C]
print(max(S))

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

Solution (Python):
import sys,queue,copy
sys.setrecursionlimit(10**8)
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())

A,B =inpl()

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

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

Ab = A+B
aB = A-B
AB = A*B

print(max(Ab, aB, AB))

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,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())
times = a*b
add= a+b
minus=a-b

if times > minus:
	if times > add:
  		print(times)
	else:
  		print(add)
else:
  if add>minus:
    print(add)
  else:
    print(minus)

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

Solution (Python):


import sys,collections,itertools,re,math,fractions,decimal,random,array,bisect,heapq





def solve(f):
    a, b = f.read_int_list()
    return max([a+b, a-b, a*b])


class Reader(object):
    def __init__(self, filename=None):
        self.file = open(filename) if filename is not None else None
        self.case = 1

    def __readline(self):
        return self.file.next().strip() if self.file else raw_input()

    def next_case(self):
        self.file.next()
        self.case += 1

    def read_int(self): return int(self.__readline())
    def read_float(self): return float(self.__readline())
    def read_long(self): return long(self.__readline())
    def read_decimal(self): return decimal.Decimal(self.__readline())
    def read_str(self): return self.__readline()

    def read_int_list(self): return map(int, self.__readline().split())
    def read_float_list(self): return map(float, self.__readline().split())
    def read_long_list(self): return map(long, self.__readline().split())
    def read_decimal_list(self): return map(decimal.Decimal, self.__readline().split())
    def read_str_list(self): return self.__readline().split()

if __name__ == '__main__':
    filename = sys.argv[1] if len(sys.argv) > 1 else None
    f = Reader(filename)
    if f.file:
        while True:
            print "Case 
            try:
                f.next_case()
            except StopIteration:
                break
    else:
        print solve(f)

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

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

Solution (Python):

from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import *
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float('INF')


def A():
    a, b = LI()
    print(max(a + b, a - b, a * b))
    return


def B():
    k, x = LI()
    ans = []
    for i in range(x - k + 1, x + k):
        ans.append(i)
    print(*ans)
    return


def C():
    n = II()
    d = defaultdict(int)
    for _ in range(n):
        s = S()
        s.sort()
        d[tuple(s)] += 1
    ans = 0
    for i in d.values():
        ans += i * (i - 1) // 2
    print(ans)
    return


def D():
    n, m = LI()
    ab = LIR(n)
    ab.sort(key=lambda x: (x[1], x[0]), reverse=True)
    ans = 0
    for i in range(n):
        if m >= ab[i][0]:
            ans += ab[i][1]
            m -= 1
    print(ans)
    return


def E():
    return


def F():
    return


if __name__ == '__main__':
    A()

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

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

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


if __name__ == '__main__':
    solve()

Solution (Python):
num_list = [int(n) for n in input().split()]
a = num_list[0]
b = num_list[1]

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

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

A1 = A + B
A2 = A - B
A3 = A * B

print(max([A1,A2,A3]))

Solution (Python):

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

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

l = [A+B,A-B,A*B]

print(max(l))

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):
a, b = map(int, input().split())

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

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

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

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

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


if __name__ == "__main__":
    main()

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

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

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

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

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

ad=int(A)+int(B)
mi=int(A)-int(B)
de=int(A)*int(B)

math=[ad,mi,de]

m_max=max(math)

print(m_max)

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

result = [A + B, A - B, A * B]
result.sort(reverse=True)
print(result[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())
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 = (int(x) for x in input().split())
print(max(a + b, a - b, a * b))

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

sum_val = a + b
sub_val = a - b
mul_val = a * b

print(max(sum_val, sub_val, mul_val))

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

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 = list(map(int, input().split()))
L = []
L.append(A_B[0] + A_B[1])
L.append(A_B[0] - A_B[1])
L.append(A_B[0] * A_B[1])
print(max(L))

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

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

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

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

Solution (Python):
def main():
    a, b = map(int, open(0).read().split())

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

    ans = max(add, sub, mult)
    print(ans)
    return()

if __name__ == '__main__':
    main()

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

Solution (Python):
A, B = map(int, input().split())
print("{}".format(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 = max(A+B,A-B)
ans = max(ans,A*B)
print(ans)

Solution (Python):

import sys


def solve(A: int, B: int):
    add = A + B
    sub = A - B
    mul = A * B

    result = max(max(add, sub), mul)

    print(result)
    return


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

Solution (Python):
L = list(map(int, input().split()))
A,B = L[0],L[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):
n=[int(i) for i in input().split()]
ans=n[0]+n[1]
if(ans<n[0]-n[1]):ans=n[0]-n[1]
if(ans<n[0]*n[1]):ans=n[0]*n[1]
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):
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):
def main():

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

if __name__ == "__main__":
    main()

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

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

Solution (Python):
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=sys.stdin.readline
def resolve():
    a,b=map(int,input().split())
    print(max(a+b,a-b,a*b))
resolve()

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

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

Solution (Python):
a, b = [int(x) for x in input().split()]
abp = a + b
abm = a - b
abt = a * b
if abp > abm:
  if abp > abt:
    print(abp)
  else:
    print(abt)
else:
  if abm > abt:
    print(abm)
  else:
    print(abt)

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

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

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

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

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

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

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

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

a,b = int(a), int(b)

total = a+b

if a*b > total:
  total = a*b

if a-b > total:
  total = a-b
  
print(total)

Solution (Python):
import sys
input = 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):
a,b=map(int,input().split())
print(max(a+b,a-b,a*b))

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

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
import math
import itertools

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 = [int(i) for i in input().split()]

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

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

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

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):
AB=input()
AB=AB.split(" ")
A=int(AB[0])
B=int(AB[1])
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):
import numpy as np
x,y = map(int,input().split())
print(np.max([x*y,x+y,x-y]))

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

Solution (Python):
ab = input()
ablist = ab.rsplit(" ")

abadd = int(ablist[0]) + int(ablist[1])

abminus = int(ablist[0]) - int(ablist[1])

abmultiply = int(ablist[0]) * int(ablist[1])

if abadd > abminus:
 if abadd > abmultiply:
  print(abadd)
 else:
  print(abmultiply)
else:
 if abminus > abmultiply:
  print(abminus)
 else:
  print(abmultiply)

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

Solution (Python):
N = input().split()
A = int(N[0])
B = int(N[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)

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

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

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())
As = list()
As.append(A + B)
As.append(A - B)
As.append(A * B)
print(max(As))

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

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

Solution (Python):


i = [int(i) for i in input().split(' ') for l in range(1)]

print(max(i[0] + i[1], i[0] - i[1], i[0] * i[1]))

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

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())
c=[a+b,a-b,a*b]
c.sort()
print(c[2])

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

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

print(max(wa, sa, seki))

Solution (Python):
a,b=map(int,input().split())
x=a+b
if x<(a*b):
  x=a*b
elif x<(a-b):
  x=a-b
print(x)

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

ans = A[0] + A[1]

if A[0] * A[1] > ans:
    ans = A[0] * A[1]
if A[0] - A[1] > ans:
    ans = A[0] - A[1]

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

Solution (Python):
a, b = map(int, input().split())
arr = []
add_ab = a + b
arr.append(add_ab)
subtraction_ab = a - b
arr.append(subtraction_ab)
multiplication_ab = a * b
arr.append(multiplication_ab)
answer = max(arr)
print(answer)

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

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

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

for i in range(3):
    c.append(a+b)
    c.append(a-b)
    c.append(a*b)

print(str(max(c)))

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

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

X.sort()

print(X[2])

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

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

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):
from sys import exit, stderr, stdin
input = stdin.readline


def debug(var, name="hoge"):
    print(name +":" + str(type(var)) + " = " + repr(var), file=stderr)
    return


def main():
    A, B = [int(n) for n in input().split()]
    print(max(A-B, A+B, A*B))



if __name__ == "__main__":
    main()

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

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

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

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

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

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

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

Solution (Python):
I0 = lambda :map(int,input().split())
I1 = lambda :int(input())
I2 = lambda :list(map(int,input().split()))

A,B = I0()
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
if x >= y and x >= z:
    print(x)
elif y >= z:
    print(y)
else:
    print(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):
import sys
input = sys.stdin.readline


def main(a, b):
    res = [0]*3
    res[0] = a + b
    res[1] = a - b
    res[2] = a * b

    return max(res)


if __name__ == "__main__":
    a, b = map(int, input().split())
    print(main(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,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):
def found_max(a,b):
    return max(a*b,a+b,a-b)

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

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

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):
a,b =map(int,input().split())

tasu = a+b
hiku = a-b
kake = a*b

l = [tasu,hiku,kake]

print(max(l))

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

num1 = x + y
num2 = x - y
num3 = x * y

if num1 > num2:
    if num1 > num3:
        ans = num1
    else:
        ans = num3
elif num2 > num3:
    ans = num2
else:
    ans = num3

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,max(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):

import collections

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

x1 = a+b
x2 = a-b
x3 = a*b

result_L = [x1,x2,x3]

print(max(result_L))

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

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

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

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

print(max(li))

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

x1 = a+b
x2 = a-b
x3 = a*b

result_L = [x1,x2,x3]

print(max(result_L))

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

Solution (Python):

a, b = map(int, input().split())
x1 = a + b
x2 = a - b
x3 = a * b

if x1 >= x2 and x1 >= x3:
    print(x1)
elif x2 >= x1 and x2 >=x3:
    print(x2)
elif x3 >= x1 and x3 >= x2:
    print(x3)

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 = map(int, input().split())
i=a+b
j=a-b
k=a*b
print(max(i,j,k))

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

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]
     
print(max(c))

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

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
input=sys.stdin.readline

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

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

print(max(answer))

Solution (Python):
def maximum(a,b):
    x = [a+b,a-b,a*b]
    return max(x)
  
A, B = map(int, input().split())
print(maximum(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())
li=[A+B,A-B,A*B]
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())
x = a+b
y = a-b
z = a*b
print(max(x,y,z))

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

lis = [x*y,x+y,x-y]
print(max(lis))

Solution (Python):
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 = 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, a-b, a*b]
print(max(tmp))

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):
if __name__ == '__main__':
    
    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):
A, B= map(int, input().split())
c= A+B
d= A-B
e= A*B
f=max(c, d, e)
print(f)

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

l = []

l.append(a+b)
l.append(a-b)
l.append(a*b)

ans = max(l)

print(ans)

Solution (Python):
A = list(map(int,input().split()))
sum = A[0] + A[1]
dif = A[0] - A[1]
tim = A[0] * A [1]
B = [sum,dif,tim]
B.sort()
print(B[2])

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

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

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

print(x)

Solution (Python):
ls = [int(i) for i in input().split()]

a = ls[0]
b = ls[1]

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

print(max(s,d,m))

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

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

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

print(max(add, diff, mul))

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

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

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

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

print(max(lst))

Solution (Python):
from sys import stdin
 
a, b = [int(x) for x in stdin.readline().rstrip().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())
 
ab1=a+b
ab2=a-b
ab3=a*b
print (max(ab1,ab2,ab3))

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

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

if __name__ == "__main__":
    main()

Solution (Python):
if __name__ == '__main__':
    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):
nums = input().split(" ")
a = int(nums[0])
b = int(nums[1])
list = []
list.append(a+b)
list.append(a-b)
list.append(a*b)
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())
print(max(A+B,A-B,A*B))

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

a = i[0]+i[1]
b = i[0]*i[1]
c = i[0]-i[1]

print(max(a,b,c))

Solution (Python):
A,B = map(int,input().split())
List = [A+B,A-B,A*B]
List = sorted(List)
print (List[-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())
M = A + B
N = A - B
R = A * B
print(max(M, N, R))