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

logging.basicConfig(level=logging.INFO, format="%(message)s")


def main():
    A, B = map(int, input().split())
    logging.info("Hello!")

    print(max([A + B, A - B, A * B]))
    
if __name__ == "__main__":
    main()

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

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

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

print(max(ans1, ans2, ans3))

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

atb = A + B
ahb = A - B
akb = A * B

print(max([atb, ahb, akb]))

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

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

Solution (Python):



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

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

print(max(p,m,mul))

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

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

Solution (Python):
"""
AtCoder
    :author: vierbein
"""
from __future__ import absolute_import, division, print_function



import sys


def pp(*args, **kwargs):
    print(*args, file=sys.stderr, **kwargs)


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

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

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

Solution (Python):
import sys,heapq,math,resource
from collections import deque,defaultdict
printn = lambda x: sys.stdout.write(x)
inn = lambda : int(input())
inl   = lambda: list(map(int, input().split()))
inm   = lambda:      map(int, input().split())
DBG = True 
R = 10**9 + 7

def ddprint(x):
  if DBG:
    print(x)

def setrlim():
  sys.setrecursionlimit(250000)
  soft,hard = resource.getrlimit(RLIMIT_STACK)
  
  

a,b = inm()
x = max([a+b,a-b,a*b])
print(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):
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**9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def LIST(): return [int(x) for x in input().split()]
MOD = 10**9 + 7

A, B = LIST()

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(str(max(ans)))

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

plus = AB[0] + AB[1]
minus = AB[0] - AB[1]
mul = AB[0] * AB[1]

if plus > minus:
    if plus > mul:
        print(plus)
    else:
        print(mul)
else:
    if minus > mul:
        print(minus)
    else:
        print(mul)

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

Solution (Python):
"""
https://atcoder.jp/contests/abc137/tasks/abc137_a
"""

import numpy as np


def calc(A: int, B: int) -> int:
    return max(A + B, A - B, A * B)


def load_input_as_int_array() -> np.ndarray:
    return np.array([int(v) for v in input().split(" ")])


def main() -> None:
    A, B = load_input_as_int_array()
    result = calc(A, B)
    print(result)


main()

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

a1=a-b
a2=a+b
a3=a*b

li = [a1,a2,a3]

print(max(li))

Solution (Python):
import sys
a, b = map(int, raw_input().split())

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

print x

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

a_1 = a + b
a_2 = a * b
a_3 = a - b

print(max(a_1,a_2,a_3))

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

apb = A + B
asb = A - B
amb = A * B

print(max([apb, asb, amb]))

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 = []
res.append(a+b)
res.append(a-b)
res.append(a*b)
res.sort(reverse=True)
print(res[0])

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

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

Solution (Python):


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

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

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

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

f = [c,d,e]

f.sort()

print(f[2])

Solution (Python):
import sys

def solve(a, b):
  return max(a + b, a - b, a * b)


if __name__ == '__main__':
  a, b = map(int, sys.stdin.readline().strip().split(" "))
  print solve(a, b)

Solution (Python):



A, B = (int(i) for i in input().split())  


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

ans = max(plus, minus, multiple)

print(ans)

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

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

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

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

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())
plus = A + B
minus = A - B
c = max(plus, minus)

print(max(c, A*B))

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

print(max(arr))

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

ans1 = a+b
ans2 = a-b
ans3 = a*b
print(max([ans1,ans2,ans3]))

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

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

print("{}".format( 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):
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())
l=[a*b,a+b,a-b]
print(max(l))

Solution (Python):
A, B  = list(map(int,input().split(' ')))
ans = []
for i in range(3):
  ans.append(A+B)
  ans.append(A-B) 
  ans.append(A*B)
  
print(max(ans))

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

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

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

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

print(max(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
import math
import copy
import re
import sys


inf = float("inf")
prime = 1

def check_print(check_flag, text, end="\n"):
  if check_flag:
    print(text, end=end)

def c2i(x):
    if str.isdecimal(x):
        return int(x)
    else:
        return x

def cout(*args):
  arglist = []
  for arg in args:
    if hasattr(arg, "__iter__"):
      arglist.extend(arg)
    else:
      arglist.append(arg)
      
  arglist = list(map(str, arglist))
  print(" ".join(arglist))
  
def count2(num):
  count=0
  while num%2==0:
    num/=2
    count+=1
  return count

def ketasum(num):
  nums = [int(s) for s in str(num)]
  return sum(nums)


def gcd(a, b): 
  while b:
    a, b = b, a % b
  return a

def lcm(a, b): 
  return a * b // gcd (a, b)

def gcd3(lis): 
  ans = lis[0]
  for li in lis:
    ans = gcd(ans,li)

def lcm3(lis): 
  ans = lis[0]
  for li in lis:
    ans = lcm(ans,li)

def divisor(n): 
  i = 1
  table = []
  while i * i <= n:
    if n%i == 0:
      table.append(i)
      table.append(n//i)
    i += 1
  table = list(set(table))
  return table

def prime_decomposition(n):
  i = 2
  table = []
  while i * i <= n:
    while n % i == 0:
      n /= i
      table.append(i)
    i += 1
  if n > 1:
    table.append(n)
  return table

def is_prime(n):
  for i in range(2, n + 1):
    if i * i > n:
      break
    if n % i == 0:
      return False
  return n != 1


"""
n = int(input())


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

d=[]
for i in range(n):
  d[i]=int(input())


a = [list(map(int, input().split())) for i in range(n)]

s = input()
ss =  [int(si) for si in s]
"""


"""
a = sorted(a)
a = sorted(a, reverse=True)

"""


"""
pattern = ""
result = re.search(pattern, s)

result = re.fullmatch(pattern, s)

result = re.finditer(pattern, s)
for res in result:
    print res.group()   
    print res.start()   
    print res.end()     
    print res.span()    
"""


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


if __name__ == '__main__':
    main()

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

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

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


if __name__ == "__main__":
    print(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):
m, n = map(int, input().split())
print(max(m + n, m - n, m * n))

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

Solution (Python):


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

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

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

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

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

list=[tmp1,tmp2,tmp3]

print(max(list))

Solution (Python):

def main():
    A, B = [int(f) for f 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())

C = A + B

if A * B > C:
    C = A * B

if A - B > C:
    C = A - B

print(C)

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

Solution (Python):
def int_multiple():
    return  [int(c) for c in input().split()]

def int_single():
    return int(input())

def str_multiple():
    return [c for c in input().split()]

def str_single():
    return input()


a, b = int_multiple()

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

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

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

print(result)

Solution (Python):
import sys,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 = (int(x) for x in 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())

aplusb = a + b
ahikub = a - b
akakerub = a * b

ans = max(aplusb, ahikub, akakerub)
print(ans)

Solution (Python):
a,b=[int(k) for k 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())
X=max(A-B,A+B,A*B)
print(X)

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

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

print(max(sum,sub,bay))

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

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

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

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

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

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

Solution (Python):
import numpy as np

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

if B > 0:
    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):

b, c = map(int, input().split())
r=b+c
if b-c>r:
    r=b-c

if b*c>r:
    r=b*c

print(r)

Solution (Python):


import copy
import sys
import math


tmp = input().split()
hoge = list(map(lambda a: int(a), tmp))

a=hoge[0]
b=hoge[1]

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


a, b = map(int, input().split())
v1 = a+b
v2 = a-b
v3 = a*b

print(max([v1,v2,v3]))

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

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

from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip


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

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




BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

input = lambda: sys.stdin.readline().rstrip("\r\n")



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

Solution (Python):
a, b = list(map(int, input().split(' ')))
x = a +b
y = a-b
z = a*b
s = []
s.append(x)
s.append(y)
s.append(z)
print(max(s))

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):
def expression(a,b):
    plus = a+b
    minus =a-b
    times = a*b

    return max([plus,minus,times])

if __name__ == '__main__':


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



    print(expression(a,b))

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

print(max(n+m,n-m,n*m))

Solution (Python):



def main():
    a, b = (int(z) for z 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):
import sys

def main():
    input = sys.stdin.readline
    a, b = map(int, input().split())
    return max(a+b, a-b, a*b)


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

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

t = a + b;
h = a - b;
k = a * b;

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

plus = A + B
m = A - B
mul = A * B
lis = sorted([plus, m, mul])
print(lis[-1])

Solution (Python):
import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  
"""

if __name__ == "__main__":
    A, B = map(int, sys.stdin.readline().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(" "))
data = []
data.append(a+b)
data.append(a-b)
data.append(a*b)
print(max(data))

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

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 = -1000

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

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

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

print(ans)

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

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

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

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

print(max(n_list))

Solution (Python):
A, B = list(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())

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

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

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

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

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

print(ans)

Solution (Python):
import sys
from collections import deque
import copy
import math
def get_read_func(fileobject):
    if fileobject == None :
        return raw_input
    else:
        return fileobject.readline



def main():
    if len(sys.argv) > 1:
        f = open(sys.argv[1])
    else:
        f = None
    read_func = get_read_func(f);
    input_raw = read_func().strip().split()
    [A, B] = [int(input_raw[0]), int(input_raw[1])]
    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())

ans = a + b

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

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

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

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

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

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=[]
for x in input().split(" "):
    a.append(int(x))

b=[a[0]+a[1],a[0]-a[1],a[0]*a[1]]
b.sort()
print(b[-1])

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

Solution (Python):


n,m=map(int,input().split())

ans=max(n+m,n-m,n*m)
print(ans)

Solution (Python):

from __future__ import division, print_function

import os
import sys
from __builtin__ import xrange as range
from cStringIO import StringIO
from future_builtins import ascii, filter, hex, map, oct, zip
from io import IOBase

import __pypy__


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




BUFSIZE = 8192


class FastI(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = StringIO()
        self.newlines = 0

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count("\n") + (not b)
            ptr = self._buffer.tell()
            self._buffer.seek(0, 2), self._buffer.write(b), self._buffer.seek(ptr)
        self.newlines -= 1
        return self._buffer.readline()


class FastO(IOBase):
    def __init__(self, file):
        self._fd = file.fileno()
        self._buffer = __pypy__.builders.StringBuilder()
        self.write = lambda s: self._buffer.append(s)

    def flush(self):
        os.write(self._fd, self._buffer.build())
        self._buffer = __pypy__.builders.StringBuilder()


def print(*args, **kwargs):
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


sys.stdin, sys.stdout = FastI(sys.stdin), FastO(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")



if __name__ == "__main__":
    main()

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

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

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

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

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

if tmp < A + B:
    tmp = A + B
if tmp < A - B:
    tmp = A - B
if tmp < A * B:
    tmp = A * B
print(tmp)

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

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

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

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

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

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

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

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

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

test = []
test.append(A + B)
test.append(A - B)
test.append(A * B)
print(max(test))

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

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

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

main()

Solution (Python):
import math
import sys
import itertools
import queue
from fractions import gcd

def lcm(a, b):
    return a * b // gcd(a, b)

mod = 1000000007

"""

a = 100
b = 0.987654321
print("{0:06d}-{1:6f}".format(a,b))
000100-0.987654


char_list = list("abcd") 



    = sys.stdin.readline().rstrip()
    = list(sys.stdin.readline().rstrip())


    = int(sys.stdin.readline())
    = map(int, sys.stdin.readline().split())
    = list(map(int, sys.stdin.readline().split()))
    = [list(map(int,list(sys.stdin.readline().split()))) for i in range(h)]  
"""

if __name__ == "__main__":
    A,B= map(int, sys.stdin.readline().split())
    l=[A+B,A-B,A*B]
    print(max(l))

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

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

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

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

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

print(max_num)

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

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

tasu = A+B
hiku = A-B
kake = A*B
print(max(tasu,hiku,kake))