Problem:
 Score : 100 points    Problem Statement You are given two integers A and B .
Find the largest value among A+B , A-B and A \times B .      Constraints  -1000 \leq A,B \leq 1000  All values in input are integers.         Input Input is given from Standard Input in the following format:  A  B       Output Print the largest value among A+B , A-B and A \times B .        Sample Input 1 3 1      Sample Output 1 4  3+1=4 , 3-1=2 and 3 \times 1=3 . The largest among them is 4 .       Sample Input 2 4 -2      Sample Output 2 6  The largest is 4 - (-2) = 6 .       Sample Input 3 0 0      Sample Output 3 0

Solution (Python):

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
bisect_left = bisect.bisect_left
bisect_right = bisect.bisect_right
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list(map(lambda x: int(x)-1, stdin.readline().split()))
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().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():
    return


def C():
    n = II()
    s = S()
    dp = [0 for i in range(n)]
    for num,si in enumerate(s):
        if si == "E":
            dp[num] = dp[num-1]+1
        else:
            dp[num] = dp[num - 1]
    ans = float("INF")
    a = max(dp)
    for i in range(n):
        ans = min(ans,  a - dp[i] + i - dp[i] + (s[i] == "E"))
    
    print(ans)
    return


def D():
    return


def E():
    return


def F():
    return


def G():
    return


def H():
    return


if __name__ == '__main__':
    A()

Solution (Python):



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




max_num = A + B

if max_num < A - B:
    max_num = A - B
    
if max_num < A * B:
    max_num = A * B





print(max_num)

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

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

Solution (Python):
from functools import reduce
import math

def main():
    
    
    
    

    
    
    
    
    
    

    
    

    
    
    
    
    
    
    
    
    
    INF = float("inf")

    
    MOD = 10**9+7
    
    
    
    
    
    
    
    
    
    
    
    
    
    
    

    
    
    
    
    a,b = (int(_) for _ in 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):
import sys

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

if __name__ == "__main__":
    a, b = map(int, input().split())

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

Solution (Python):

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

s = []
s.append(l[0] + l[1])
s.append(l[0] - l[1])
s.append(l[0] * l[1])

print(max(s))

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



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

print(max(ls))

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

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

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

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

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

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

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

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

add = A+B
sub = A-B
mul = A*B
print(max(add,sub,mul))

Solution (Python):
nl = lambda: list(map(int, input().split()))
sl = lambda: input().split()
n = lambda: int(input())
s = lambda: input()

A, B = nl()

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

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

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

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

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

Solution (Python):

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

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

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

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

print(max(ans))

Solution (Python):
A, B = [int(ab) for ab in input().split()]
C = A+B
D = A-B
E = A*B
ans = max(C, D, E)
print(ans)

Solution (Python):
if __name__ == '__main__':
    A, B = map(int, input().split())

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

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


abc()

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

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

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

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

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

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

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

print(ans)

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

ansa= a+b
ansb= a-b
ansc= a*b
li = [ansa,ansb,ansc]

print(max(li))

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

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

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

print(max(ans1,ans2,ans3))

Solution (Python):
A, B = map(int, raw_input().split())
lst = [A+B, A-B, A*B]
lst.sort()
print lst[-1]

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

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

Solution (Python):
a, b = [ int(v) for v in 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

nums=[x,y,z]

print(max(nums))

Solution (Python):

import sys


def solve(A: int, B: int):
    print(max(A+B,A-B,A*B))



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

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

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

input_list.sort(reverse=True)

print(input_list[0])

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

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

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

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

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

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

Solution (Python):

import sys


def solve(A: int, B: int):
    ret = max(A + B, A - B, A * B)
    print(ret)
    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):


from sys import stdout
from bisect import bisect_left as binl
from copy import copy, deepcopy
from collections import defaultdict


mod = 1


def intin():
    input_tuple = input().split()
    if len(input_tuple) <= 1:
        return int(input_tuple[0])
    return tuple(map(int, input_tuple))


def intina():
    return [int(i) for i in input().split()]


def intinl(count):
    return [intin() for _ in range(count)]


def modadd(x, y):
    global mod
    return (x + y) % mod


def modmlt(x, y):
    global mod
    return (x * y) % mod


def lcm(x, y):
    while y != 0:
        z = x % y
        x = y
        y = z
    return x


def combination(x, y):
    assert(x >= y)

    if y > x // 2:
        y = x - y

    ret = 1

    for i in range(0, y):
        j = x - i
        i = i + 1

        ret = ret * j
        ret = ret // i

    return ret


def get_divisors(x):
    retlist = []
    for i in range(1, int(x**0.5) + 3):
        if x % i == 0:
            retlist.append(i)
            retlist.append(x // i)
    return retlist


def get_factors(x):
    retlist = []
    for i in range(2, int(x**0.5) + 3):
        while x % i == 0:
            retlist.append(i)
            x = x // i
    retlist.append(x)
    return retlist


def make_linklist(xylist):
    linklist = {}
    for a, b in xylist:
        linklist.setdefault(a, [])
        linklist.setdefault(b, [])
        linklist[a].append(b)
        linklist[b].append(a)
    return linklist


def calc_longest_distance(linklist, v=1):
    distance_list = {}
    distance_count = 0
    distance = 0
    vlist_previous = []
    vlist = [v]
    nodecount = len(linklist)

    while distance_count < nodecount:
        vlist_next = []
        for v in vlist:
            distance_list[v] = distance
            distance_count += 1
            vlist_next.extend(linklist[v])
        distance += 1
        vlist_to_del = vlist_previous
        vlist_previous = vlist
        vlist = list(set(vlist_next) - set(vlist_to_del))

    max_distance = -1
    max_v = None
    for v, distance in distance_list.items():
        if distance > max_distance:
            max_distance = distance
            max_v = v

    return (max_distance, max_v)


def calc_tree_diameter(linklist, v=1):
    _, u = calc_longest_distance(linklist, v)
    distance, _ = calc_longest_distance(linklist, u)
    return distance





def main():
    a, b = intin()

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

    print(max([c, d, e]))

if __name__ == '__main__':
    main()

Solution (Python):
import sys, os

f = lambda:list(map(int,input().split()))
if 'local' in os.environ :
    sys.stdin = open('./input.txt', 'r')

def solve():
    a,b = f()
    print(max(a+b, a-b, a*b))

solve()

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

s = []
s.append(l[0] + l[1])
s.append(l[0] - l[1])
s.append(l[0] * l[1])

print(max(s))

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

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

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

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

Solution (Python):
from collections import defaultdict
import sys,heapq,bisect,math,itertools,string,queue,datetime
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inpl(): return list(map(int, input().split()))
def inpl_str(): return list(input().split())

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

Solution (Python):




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


c_max = a + b
mi = a - b
ti = a * b

if c_max < mi:
    c_max = mi
if c_max < ti:
    c_max = ti
    

print(c_max)

Solution (Python):




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


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


print(c_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):
import sys


def input():
    return sys.stdin.readline()[:-1]








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

k=a+b
m=a-b
n=a*b

print(max(k,m,n))

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


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


def submit():
    a, b = read_input()

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

if __name__ == '__main__':
    submit()

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

minAns = -1000001
tmp1 = A + B
tmp2 = A * B
tmp3 = A - B
minAns = max(minAns, tmp1, tmp2, tmp3)

print(minAns)

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

import numpy as np
import math
import re

n = input()

n = re.split(" ",n)

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

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

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, 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
import math
import re

n = input()

n = re.split(" ",n)

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

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

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

import sys


def solve(A: int, B: int):
    ret = max(A + B, A * B, A - B)
    print(ret)



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

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

Solution (Python):
ab=input().split()
a=int(ab[0])
b=int(ab[1])
ans_list=[a+b,a-b,a*b]
ans_list.sort()
ans=ans_list[2]
print(ans)

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

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

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

Solution (Python):
A, B = map(int, input().split())
X = A + B
Y = A - B
Z = A * B
if X >= Y and X >= Z:
    print(X)
elif Y >= X and Y >= Z:
    print(Y)
elif Z >= X and Z >= Y:
    print(Z)

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

Solution (Python):
a,b = map(int,input().split())
c = []
c.append(a*b)
c.append(a+b)
c.append(a-b)
c = sorted(c)
print(c[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, 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):
A, B = map(int, input().split())
C = A + B
D = A - B
E = A * B
ans = max(C,D,E)
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())  
ans = max(A+B, A-B, A*B)
print(ans)

Solution (Python):
import functools

import os

INF = float('inf')


def inp():
    return int(input())


def inpf():
    return float(input())


def inps():
    return input()


def inl():
    return list(map(int, input().split()))


def inlf():
    return list(map(float, input().split()))


def inls():
    return input().split()


def debug(fn):
    if not os.getenv('LOCAL'):
        return fn

    @functools.wraps(fn)
    def wrapper(*args, **kwargs):
        print('DEBUG: {}({}) -> '.format(
            fn.__name__,
            ', '.join(
                list(map(str, args)) +
                ['{}={}'.format(k, str(v)) for k, v in kwargs.items()]
            )
        ), end='')
        ret = fn(*args, **kwargs)
        print(ret)
        return ret

    return wrapper

a, b = inl()
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())
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().rstrip().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(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):

import sys
INF = float("inf")


def solve(A: int, B: int):
    print(max([A+B, A-B, A*B]))
    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 = 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())
P=A+B
M=A-B
MUL=A*B

print(max(P,M,MUL))

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

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

if add > sub and add > mul:
    print(add)
elif sub > add and sub > mul:
    print(sub)
elif mul > add and mul > sub:
    print(mul)
else:
    print(add)

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

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

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

Solution (Python):
A, B = map(int, input().split())
res = 0
res = A + B
res = max(res, 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):
i = list(map(int, input().split()))
A = i[0]
B = i[1]

a = 0
s = 0
m = 0

def add(a, b):
  return a + b

def sub(a, b):
  return a - b

def mul(a, b):
  return a * b

a = add(A, B)
s = sub(A, B)
m = mul(A, B)

print(max(a, s, 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())
x=a+b
y=a-b
z=a*b
if y<=x and z<=x:
    print(x)
elif x<=y and z<=y:
    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())
a = A + B
if A * B > a:
    a = A * B
if A - B > a:
	a = A - B
print(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())
sum=a+b
dif=a-b
prod=a*b
print(max(sum,dif,prod))

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

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):
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(_) for _ 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())
d=a+b
e=a-b
f=a*b
print(max(d, e, f))

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