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

Solution (Python):

def atc_137a(input_value: str) -> int:
    A, B = map(int, input_value.split(" "))
    return max(A + B, A - B, A * B)

input_value = input()
print(atc_137a(input_value))

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

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

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

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

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

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

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

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

print(max(add, sub, multi))

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

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

su = a + b
mi = a - b
ka = a * b

print(max([su,mi,ka]))

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

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

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

cal = [A+B,A-B,A*B]
cal.sort()
print(cal[-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())

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

print(max(sum, sub, 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())

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

print(max(add, sub, div))

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

i = a + b
j = a - b
k = a * b

print(max(i, 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())
plus = A + B
minus = A - B
times = A * B
print(max(plus, minus, times))

Solution (Python):
integer1, integer2 = map(int, input().split())
if integer1 + integer2 >= integer1 - integer2:
    if integer1 + integer2 >= integer1 * integer2:
        print(integer1 + integer2)
    else:
        print(integer1 * integer2)
elif integer1 - integer2 >= integer1 * integer2:
    print(integer1 - integer2)
else:
    print(integer1 * integer2)

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(n) for n in input().split()]
print(int(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())

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

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

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

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

AB_add = A + B
AB_sub = A - B
AB_mul = A * B

AB_list = [AB_add, AB_sub, AB_mul]

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, input().split())
l = [A+B, A-B, A * B]
l.sort(reverse=True)
print(l[0])

Solution (Python):
'''
問題：
    整数 A, B があります。

    A + B, A − B, A ×B
    の中で最大の数を出力してください。
'''

'''
制約：
入力は全て整数である。
−100 ≤ A, B ≤ 100
'''


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

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

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

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

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

print(result)

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


def atc_137a(input_value: str) -> int:
    A, B = map(int, input_value.split(" "))
    return max(A + B, A - B, A * B)

input_value = input()
print(atc_137a(input_value))

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)
elif A-B >= A*B:
    print(A-B)
else:
    print(A*B)

Solution (Python):

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

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

print(answer)

Solution (Python):




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

if (A + B) <= (A - B):
    if (A - B) <= (A * B):
        answer = A * B
    else:
        answer = A -B
elif (A + B) <= (A * B):
    answer = A * B
else:
    answer = A + B

print(answer)

Solution (Python):


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

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

print(max(lists))

Solution (Python):
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")


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

Solution (Python):
import sys
sys.setrecursionlimit(10**9)

def mi(): return map(int,input().split())
def ii(): return int(input())
def isp(): return input().split()
def deb(text): print("-------\n{}\n-------".format(text))

INF=10**20
def main():
    a,b = mi()
    print(max(a*b,a-b,a+b))



if __name__ == "__main__":
    main()

Solution (Python):
a,b=map(int,input().split())
p=a+b
x=a*b
m=a-b
if(p>=x and p>=m):
  print(p)
elif(x>=p and x>=m):
  print(x)
else:
  print(m)

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

Solution (Python):

c_list = list(map(int,input().split()))
l_cnt = len(c_list)


calc_dic = {"add":int(c_list[0]),
            "sub":int(c_list[0]),
            "mul":int(c_list[0])}
for cnt in range(1,l_cnt,1):
    calc_dic["add"] = calc_dic["add"] + c_list[cnt]
    calc_dic["sub"] = calc_dic["sub"] - c_list[cnt]
    calc_dic["mul"] = calc_dic["mul"] * c_list[cnt]
print(max(calc_dic.values()))

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

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

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())
j_list=[A+B,A-B,A*B]
j_list.sort()
print(j_list[2])

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

max_math = max(num1 + num2, num1 - num2, num1 * num2)

print(max_math)

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

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

Solution (Python):
import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip() 
sys.setrecursionlimit(10**7)
INF = float('inf')
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()

def resolve():
    A, B = LI()

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

if __name__ == '__main__':
    resolve()

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

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

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

Solution (Python):
int_a, int_b = map(int, input().split())
lists_calc = [int_a + int_b, int_a - int_b, int_a * int_b]
print(max(lists_calc))

Solution (Python):
import sys


def main():
    input = sys.stdin.buffer.readline
    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())

c = A + B
d = A - B 
e = A * B

F = [c, d, e]

print(max(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(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

readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)


def main():
    A, B = map(int, readline().split())

    x, y, z = A + B, A - B, 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):
a,b=map(int,input().split())
x=a+b
y=a-b  
z=a*b
res=max(x,y)
print(max(res,z))

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

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())
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())
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 = 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
if c>=d and c>=e:
  print(c)
elif d>=c and d>=e:
  print(d)
else:
  print(e)

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

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

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

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

Solution (Python):
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))

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

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

def main():
    a, b = Input()
    return max(a*b, a-b, a+b)


print(main())

Solution (Python):

a, b = map(int, input().split())
x = a + b
y = a - b
z = a * b
O = [x,y,z]
O = sorted(O,reverse=1)
print(O[0])

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


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

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

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

Solution (Python):


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

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

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 ())
P = A+B
M = A-B
K = A*B
if P>=M>=K or P>=K>=M:
  print (P)
elif M>P>K or M>K>P:
  print (M)
else:
  print (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())

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

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

ans = A+B
if A-B > ans:
    ans = A-B
if A*B > ans:
    ans = 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, 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=a+b
y=a-b
z=a*b

print(max(x,y,z))

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

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):
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return map(int,input().split())
def lmp(): return list(map(int,input().split()))

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

Solution (Python):


import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)

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

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

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

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

print(max(plus,minus,mal))

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

Solution (Python):
n,m = input().split()
A = int(n)
B = int(m)
if (A + B <= A - B <= A * B) or (A - B <= A + B <= A * B):
    print(A * B)
elif(A - B <= A * B <= A + B) or (A * B <= 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):
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())
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())
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):
inp=list(map(int,input().split()))
a=inp[0]
b=inp[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())
print(max(a+b,a-b,a*b))

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())
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)
else:
    print(z)

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7) 
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right

from collections import deque, defaultdict


from collections import Counter

from itertools import accumulate,combinations,permutations,product

from heapq import heapify,heappop,heappush

from functools import reduce,lru_cache

from decimal import Decimal

def input(): 
    x=sys.stdin.readline()
    return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False): 
    inds=sorted(range(len(s)), key=lambda k: s[k])
    if return_sorted: return inds, [s[i] for i in inds]
    return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
    K,N,M=len(B),len(A),len(B[0])
    return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
    N,size=len(v),len(M)
    return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
    n,m=len(M),len(M[0])
    return [[M[j][i] for j in range(n)] for i in range(m)]
def binr(x): return bin(x)[2:]
def bitcount(x): 
    x= x - ((x >> 1) & 0x5555555555555555)
    x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
    x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f 
    x+= (x >> 8); x+= (x >> 16); x+= (x >> 32) 
    return x & 0x7f

def main():
    mod = 1000000007
    

    
    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())
l = []
l.append(a+b)
l.append(a-b)
l.append(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 = list(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 = map(int, input().split())

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

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 input2():
	return map(int,input().split())

a,b=input2()
ans=a+b
if a-b>ans:
	ans=a-b
if a*b>ans:
	ans=a*b 
print(ans)

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

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

Solution (Python):
import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")

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

print(ans)

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

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

Solution (Python):


def main():

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

    listNum = [(A + B), (A - B), (A * B)]

    ans = max(listNum)

    print(ans)


if __name__ == "__main__":
    main()

Solution (Python):
import numpy as np
A, B = map(int, input().split())
data = np.array([A+B, A-B, A*B])
ans = data.max()
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=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):















































global FLAG_LOG
FLAG_LOG = False


def log(value):
    
    
    if FLAG_LOG:
        print(str(value))


def calculation(lines):
    
    
    A, B = list(map(int, lines[0].split()))
    
    
    
    
    
    
    
    

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



def get_input_lines(lines_count):
    lines = list()
    for _ in range(lines_count):
        lines.append(input())
    return lines



def get_testdata(pattern):
    if pattern == 1:
        lines_input = ['-13 3']
        lines_export = [-10]
    if pattern == 2:
        lines_input = ['1 -33']
        lines_export = [34]
    if pattern == 3:
        lines_input = ['13 3']
        lines_export = [39]
    return lines_input, lines_export



def get_mode():
    import sys
    args = sys.argv
    global FLAG_LOG
    if len(args) == 1:
        mode = 0
        FLAG_LOG = False
    else:
        mode = int(args[1])
        FLAG_LOG = True
    return mode



def main():
    import time
    started = time.time()
    mode = get_mode()
    if mode == 0:
        lines_input = get_input_lines(1)
    else:
        lines_input, lines_export = get_testdata(mode)

    lines_result = calculation(lines_input)

    for line_result in lines_result:
        print(line_result)

    
    
    
    
    
    
    
    
    
    
    



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

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

Solution (Python):
a,b=list(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):
p = list(map(int, input().split()))
ans = max(p[0]+p[1], p[0]-p[1], p[0]*p[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())
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
def MI(): return map(int,sys.stdin.readline().rstrip().split())

A,B = MI()
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())
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
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)

A, B = mapint()
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())
s = a+b
t = a-b
u = a*b

if s >= t:
    if s >= u:
        print(s)
    else:
        print(u)
elif t >= u:
    if t >= s:
        print(t)
    else:
        print(s)
elif u >= s:
    if u >= t:
        print(u)
    else:
        print(t)

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

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

Solution (Python):
import sys


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


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


if __name__ == "__main__":
    main()

Solution (Python):
import sys
A,B = map(int,input().split())
if not ( -100 <= A <= 100 and -100 <= B <= 100 ): sys.exit()

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

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())
x = []

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

x = sorted(x)

print(x[2])

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

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

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