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())
array = [0]*3
array[0]=a+b
array[1]=a-b
array[2]=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())
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 = [int(x) for x in 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())
print(max((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 math
import bisect
import atexit
import io
import heapq
from collections import defaultdict, Counter
MOD = int(1e9+7)





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



main()

Solution (Python):
import sys
sys.setrecursionlimit(100000)
input=sys.stdin.readline
def intinput():return map(int,input().split())

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

mx = -15555

if mx < a-b:
    mx = a-b

if mx < a*b:
    mx = a*b

if mx < a+b:
    mx = a+b

print(mx)

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

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

Solution (Python):
A, B = [int(n) for n 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())

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

max = plus

if ( minus > max):
    max = minus

if ( kakeru > max ):
    max = kakeru

print(max)

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

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

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

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

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

Solution (Python):

def func(a, b):
    a_plus_b = a + b
    a_minus_b = a - b
    a_times_b = a * b
    print(max(a_plus_b, a_minus_b, a_times_b))

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

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

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

a, b = [int(i) for i in input().split()]
print(max(a+b,a-b,int(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):
import sys
from math import factorial
input = sys.stdin.readline

N, M = map(int, input().split())

print(max(N + M, N - M, N * M))

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

Solution (Python):
import sys

from operator import itemgetter

def main():

	input = sys.stdin.readline
	a,b = [int(item) for item in input().split()]
	print(max(max(a+b,a-b),a*b))

main()

Solution (Python):
from sys import stdin


def main():
    A, B = [int(x) for x in stdin.readline().rstrip().split()]
    print(max(A + B, A - B, A * B))


if __name__ == "__main__":
    main()

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

Solution (Python):
inputs = [int(x) for x in input().split()]
a, b = inputs[0], inputs[1]

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):
import numpy as np
a,b = map(int,input().split())
c = np.max([a-b,a+b,a*b])
print("{}".format(c))

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


if __name__ == '__main__':
    main()

Solution (Python):



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

if __name__=='__main__':
  main()

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

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

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

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

print(max(lst))

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

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

sum = a[0] + a[1]
diff = a[0] - a[1]
seki = a[0] * a[1]

print(max(sum, diff, seki))

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

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

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

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

Solution (Python):


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

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

max = -100

for calc in [A+B, A - B, A * B]:
  if calc > max:
    max = calc
print(max)

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

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

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())
sum1= a+b
sub = a-b
mul = a*b
print(max(sum1,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())
x=a+b
y=a-b
z=a*b

print(max(x,y,z))

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

sum = a+b
sub = a-b
mul = a*b
list = [sum, sub, mul]

print(max(list))

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

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

n.append(A+B)
n.append(A-B)
n.append(A*B)
          
print(max(n))

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

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

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

Solution (Python):
values = list(map(int, input().split(' ')))
AplusB = values[0] + values[1]
AminusB = values[0] - values[1]
AtimesB = values[0] * values[1]
print(max([AplusB, AminusB, AtimesB]))

Solution (Python):
import numpy as np

a,b = np.array(list(map(int,input().split())))

result = np.array([a+b,a-b,a*b])

print(result.max())

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

Solution (Python):
import time
 
time.sleep(0.5)
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())) 
C = A + B
if C < (A - B):
  C = A - B
if C < (A * B):
  C = A * B
print(C)

Solution (Python):
import numpy as np

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

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

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

print(max(sumi,sub,mul))

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

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

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

n1 = a + b
n2 = a-b
n3 = a*b
if n1 > n2 and n1 > n3:
  print(n1)
elif n2 > n3:
  print(n2)
else:
  print(n3)

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.append(int(A+B))
a.append(int(A*B))
a.append(int(A-B))
print(max(a))

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

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

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

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



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


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

Solution (Python):
import os,re,sys,operator
from collections import Counter,deque
from operator import itemgetter
from itertools import accumulate,combinations,groupby
from sys import stdin,setrecursionlimit
from copy import deepcopy
import heapq

setrecursionlimit(10**6)
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
minus = a - b
product = a * b

list = []
list.append(add)
list.append(minus)
list.append(product)
list.sort()
print(list[-1])

Solution (Python):



from sys import stdin
import math


int_list  = [int(x) for x in stdin.readline().rstrip().split()]

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

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

ans = a+b
ans2 = a*b
ans3 = a-b
if ans < ans2:
    ans = ans2

if ans < ans3:
    ans = ans3
    
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())
x = a+b
y = a-b
z = a*b

if x <= z and y<= z:
    print(z)
elif z <= x and y <= x:
    print(x)
else:
    print(y)

Solution (Python):
"""
 // Author : snape_here - Susanta Mukherjee

"""
from __future__ import division, print_function
import os,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
else:
    _str = str
    str = lambda x=b"": x if type(x) is bytes else _str(x).encode()

    


from math import ceil,floor,log,sqrt,factorial,pow,pi






  



def ii(): return int(input())
def fi(): return float(input())
def si(): return input()
def mi(): return map(int,input().split())
def li(): return list(mi())

def main():
    
    a,b=mi()
    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 _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0,2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        if self.buffer.tell():
            return self.buffer.read()
        return os.read(self._fd, os.fstat(self._fd).st_size)

    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)


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", b" "), 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", b"\n"))
    if kwargs.pop("flush", False):
        file.flush()


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



if __name__ == "__main__":
    main()

Solution (Python):
import glob
import numpy as np



REL_PATH = 'ABC\\137\\A'


TOP_PATH = 'C:\\AtCoder'

class Common:

    problem = []
    index = 0

    def __init__(self, rel_path):
        self.rel_path = rel_path

    def initialize(self, path):
        file = open(path)
        self.problem = file.readlines()
        self.index = 0
        return

    def input_data(self):
        try:
            IS_TEST
            self.index += 1
            return self.problem[self.index-1]

        except NameError:
            return input()

    def resolve(self):
        pass

    def exec_resolve(self):
        try:
            IS_TEST
            for path in glob.glob(TOP_PATH + '\\' + self.rel_path + '/*.txt'):
                print("Test: " + path)
                self.initialize(path)
                self.resolve()
                print("\n\n")
        except NameError:
            self.resolve()


class A(Common):

    def resolve(self):

        tmp = [int(i) for i in self.input_data().split()]
        A = tmp[0]
        B = tmp[1]

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

        print(str(result))


solver = A(REL_PATH)
solver.exec_resolve()

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

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

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

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

print(m)

Solution (Python):
import math
import fractions
import copy
import numpy as np
def j(q):
    if q==1: print("Yes")
    elif q == 0:print("No")
    exit(0)
rem = pow(10,9)+7
"""
def ct(x,y):
    if (x>y):print("+")
    elif (x<y): print("-")
    else: print("?")
"""

def ip():
    return int(input())
def iprow():
    return [int(i) for i in input().split()]
def ips():
    return (int(i) for i in input().split())
def printrow(a):
    for i in a:
        print(i)
"""

def combinations(n,r):
    if n<r:return 0
    return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
def permutations(n,r):
    if n<r:return 0
    return math.factorial(n) // math.factorial(n - r)
def lcm(x, y):
    return (x * y) // fractions.gcd(x, y)
"""
a,b  = ips()

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

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

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

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

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

Solution (Python):
def add(A, B):
    return (A + B)

def sub(A, B):
    return (A - B)

def mult(A, B):
    return (A * B)


def main():
    inp = input('')
    inp = inp.split()
    A = int(inp[0])
    B = int(inp[1])

    C = []
    C.append(add(A,B))
    C.append(sub(A,B))
    C.append(mult(A,B))

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

Solution (Python):
import sys

A,B = map(int,sys.stdin.readline().split())
maxNum= A+B
maxNum= max(maxNum,A-B)
maxNum= max(maxNum,A*B)
print(maxNum)

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

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

Solution (Python):
a , b = map(int , input().split())
 
def fun(a,b):
    adds = a+b
    subs = a-b
    muls = a*b
 
    if adds > subs:
        if adds > muls:
            return adds
        else:
            return muls
    else:
        if subs > muls:
            return subs
        else:
            return muls
 

 
print(fun(a,b))

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

ABsum = int(AB[0]) + int(AB[1])
ABdif = int(AB[0]) - int(AB[1])
ABmul = int(AB[0]) * int(AB[1])

list = [ABsum, ABdif, ABmul]
print(max(list))

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

j = [i[0] + i[1], i[0] - i[1], i[0] * i[1]]

j.sort(reverse=True)

print(j[0])

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())  
s = a + b
m = a - b
c = a * b
list = [s,m,c]
list.sort(reverse=True)
print(list[0])

Solution (Python):

A, B = map(int, input().split())
plus = A + B
m = A - B
malti = A * B

print(max(plus, m, malti))

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

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

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

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

if __name__ == "__main__":
    run_a()

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

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

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

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

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

ma = -1000
a1 = [a + b,a - b,a * b]
for i in a1:
  if ma < i:
    ma = i
print(ma)

Solution (Python):

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

if __name__ == '__main__':
    main()

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

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

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

Solution (Python):
from sys import exit, stdin
A, B = [int(_) for _ in stdin.readline().rstrip().split()]
print(max(A+B, A-B, A*B))

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

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

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

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

Solution (Python):
def iread():
    return int(input())


def sread():
    return input()


def aread(t="int"):
    if t == "int":
        ret = [int(i) for i in input().split()]
    elif t == "str":
        ret = list(input())
    else:
        ret = tmp
    return ret


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


def main():
    a,b = scan()
    print(max(a + b, a * b, a - b))        

if __name__ == '__main__':
    main()

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

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

print(max(plus, minus, multi))

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().rstrip().split())

cand = a + b
if a - b > cand:
  cand = a - b

if a * b > cand:
  cand = a * b
  
print(cand)

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

Solution (Python):
a, b = [int(n) for n 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(x) for x in input().split())

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

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

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

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

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

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

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

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

a = inp[0]
b = inp[1]

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


print(max(compare_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):
n=input()
print(max([eval(n.replace(' ',c)) for c in '+-*']))

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

Solution (Python):
a = []
a = input().split()

A = int(a[0])

B = int(a[1])

plu = A + B

dif = A - B

mul = A * B

max = plu

if dif > max :
	max = dif
if mul > max :
	max = mul

print(max)

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

Solution (Python):
from sys import stdin

A, B = [int(x) for x in stdin.readline().rstrip().split()]
print(max(A + B, A - B, A * B))

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

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

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

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

for i in range(2):
    x[i]=int(x[i])

y=[0]*3
y[0]=x[0]+x[1]
y[1]=x[0]-x[1]
y[2]=x[0]*x[1]
 
print(max(y))

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

for i in range(2):
    x[i]=int(x[i])

y=[0]*3
y[0]=x[0]+x[1]
y[1]=x[0]-x[1]
y[2]=x[0]*x[1]
 
print(max(y))

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

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

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

A = inputNum[0]
B = inputNum[1]

plusAnswer = A + B
minusAnswer = A - B
multiAnswer = A * B

maxAnswer = plusAnswer
if (maxAnswer < minusAnswer):
    maxAnswer = minusAnswer
if (maxAnswer < multiAnswer):
    maxAnswer = multiAnswer

print(maxAnswer)

Solution (Python):
n = list(map(int, input().split()))
a = n[0] + n[1]
b = n[0] - n[1]
c = n[0] * n[1]
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=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):
num = [int(i) for i in input().split()]
A = num[0]
B = num[1]

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

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

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

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

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= (int(i) for i in 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):
''' بِسْمِ اللَّهِ الرَّحْمَٰنِ الرَّحِيمِ '''
gi = lambda : list(map(int,input().split()))
a, b = gi()
print(max(a + b, a - b, a * b))

Solution (Python):
a, b = input().split()
a = int(a)
b = int(b)
result = []
result.append(a + b)
result.append(a - b)
result.append(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())
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 = [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())
e=a+b
f=a-b
g=a*b
print(max(e,f,g))

Solution (Python):

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


if __name__ == "__main__":
    main()

Solution (Python):

def main():
    A, B = tuple(map(int, input().rstrip().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))