Problem:
 Score : 100 points    Problem Statement We have two integers: A and B .  Print the largest number among A + B , A - B , and A \times B .      Constraints  All values in input are integers.  -100 \leq A,\ B \leq 100         Input Input is given from Standard Input in the following format:  A  B       Output Print the largest number among A + B , A - B , and A \times B .        Sample Input 1 -13 3      Sample Output 1 -10  The largest number among A + B = -10 , A - B = -16 , and A \times B = -39 is -10 .       Sample Input 2 1 -33      Sample Output 2 34  The largest number among A + B = -32 , A - B = 34 , and A \times B = -33 is 34 .       Sample Input 3 13 3      Sample Output 3 39  The largest number among A + B = 16 , A - B = 10 , and A \times B = 39 is 39 .

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

Solution (Python):
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):
import sys, re, os
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import permutations, combinations, product, accumulate
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from fractions import gcd
 
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def S_MAP(): return map(str, input().split())
def LIST(): return list(map(int, input().split()))
def S_LIST(): return list(map(str, input().split()))

sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

a1 = A + B
a2 = A - B
a3 = A * B
print(max(a1, a2, a3))

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

Solution (Python):









import sys
inf = float("inf")





mod,MOD=1000000007,998244353










def get_array(): return list(map(int , sys.stdin.readline().strip().split()))
def get_ints(): return map(int, sys.stdin.readline().strip().split())
def input(): return sys.stdin.readline().strip()

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

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

Solution (Python):

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

ans1 = A + B
ans2 = A - B
ans3 = A * B
print(max(max(ans1, ans2), ans3))

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

ansA = A + B
ansB = A - B
ansC = A * B

print(max(ansA, ansB, ansC))

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

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

x = a+b
y = a-b
z = a*b

print(max([x,y,z]))

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

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

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

Solution (Python):
from collections import Counter,defaultdict




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

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

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

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

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

print(max(sum, sub, mult))

Solution (Python):

import sys


def get_num():
    return int(input())


def get_nums(n):
    res = [0 for _ in range(n)]
    for i in range(n):
        res[i] = int(input())
    return res


def get_numbers():
    return map(int, input().split())


a, b = get_numbers()

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

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

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

Solution (Python):
import sys
sys.setrecursionlimit(10**7)
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

debug = True


def dprint(*objects):
    if debug == True:
        print(*objects)

def solve():
    a, b = LI()

    a1 = a + b
    a2 = a - b
    a3 = a * b
    print(max(a3, max(a1, a2)))

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())
C = max(A+B,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())
c1=A+B
c2=A-B
c3=A*B
print(max(c1,c2,c3))

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

main()

Solution (Python):

import sys
import math
from bisect import bisect_left
from bisect import bisect_right
import collections
import copy
import heapq
from collections import defaultdict
from heapq import heappop, heappush
import itertools
input = sys.stdin.readline






















def inputInt(): return int(input())
def inputMap(): return map(int, input().split())
def inputList(): return list(map(int, input().split()))

def main():
	A,B = inputMap()

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



if __name__ == "__main__":
	main()

Solution (Python):
import sys
def main():
    input = sys.stdin.readline
    AB = list(map(int, input().split()))
    A = AB[0]
    B = AB[1]
    li = [A+B, A-B, A*B]

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

hoge = A+B
fuga = A-B
piyo = A*B

ans = max(hoge, fuga)
ans = max(ans, piyo)

print(ans)

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
print(max([x,y,z]))

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

Solution (Python):

from collections import defaultdict, deque
import math
from math import factorial
import fractions
import re
import bisect

BIGNUM = 10 ** 9 + 7

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

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


if __name__ == '__main__':
    main()

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

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

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

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

Solution (Python):


def readInts():
  return [int(s) for s in input().split(" ")]

def main():
  A, B = readInts()
  ans = max(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 = [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 = list(map(int, input().split()))
wa = A+B
s = A*B
sa = A-B
print(max(wa,s,sa))

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

n=[0]*3

n[0]=a+b
n[1]=a-b
n[2]=a*b

print(max(n))

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

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

Solution (Python):
(A, B) = tuple([int(s) for s in 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())
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())
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())
l = [a+b,a-b,a*b]
print(max(l))

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

x = a + b
y = a - b
z = a * b
print(max(x,y,z))

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

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

main()

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):
    temp1 = A + B
    temp2 = A - B
    temp3 = A * B
    ans_list = [temp1, temp2, temp3]
    print(max(ans_list))
    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):

import bisect
import heapq
import math
import random
import sys
from collections import Counter, defaultdict, deque
from decimal import ROUND_CEILING, ROUND_HALF_UP, Decimal
from functools import lru_cache, reduce
from itertools import combinations, combinations_with_replacement, product, permutations
from operator import add, mul, sub

sys.setrecursionlimit(100000)
input = sys.stdin.readline


def read_int():
    return int(input())


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


def read_float():
    return float(input())


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


def read_str():
    return input().strip()


def read_str_n():
    return list(map(str, input().split()))


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


def mt(f):
    import time

    def wrap(*args, **kwargs):
        s = time.time()
        ret = f(*args, **kwargs)
        e = time.time()

        error_print(e - s, 'sec')
        return ret

    return wrap


@mt
def slv(A, B):
    return max([A+B, A-B, A*B])


def main():
    A, B = read_int_n()
    print(slv(A, B))


if __name__ == '__main__':
    main()

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

Solution (Python):
def InputToInt():
    A = input().split()
    for i in range(len(A)):
        A[i] = int(A[i])
    return A
    
if __name__ == '__main__':
    A, B = InputToInt()
    print(max(A+B, A-B, A*B))

Solution (Python):
import sys

sys.setrecursionlimit(10**7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def LI(): return list(map(int, sys.stdin.readline().split()))
def II(): return int(sys.stdin.readline())
def LS(): return list(map(list, sys.stdin.readline().split()))
def S(): return list(sys.stdin.readline())[:-1]

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

if __name__ == '__main__':
    main()

Solution (Python):

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

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

Solution (Python):
import sys


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


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

Solution (Python):
if __name__ == '__main__':

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

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

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

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

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

Solution (Python):

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

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

pl = a+b
mi = a - b
mul = a * b
ans = max(pl, mi, mul)

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

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

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

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

Solution (Python):
import sys

a,b= [ int(x) for x in sys.stdin.readline().split() ]
print( max(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().rstrip()

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

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

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

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

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

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

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

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

Solution (Python):
A, B = map(int, input().split())
print(max(A + B, 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):
words = lambda t : list(map(t, input().split()))
a,b = words(int)
print(max(a+b,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(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):
a,b = map(int,input().split())
print(max(a+b,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):
import sys

def input(): return sys.stdin.readline()[:-1]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def MATINT(h): return [list(map(int, input().split())) for _ in range(h)]
def MATSTR(h): return [input() for _ in range(h)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
inf = float('inf')
mod = 10 ** 9 + 7

def main():
    A, B = MAP()
    X = [A + B, A * B, A - B]
    print(max(X))


if __name__ == '__main__':
    main()

Solution (Python):
hoge = input().split()
A = int(hoge[0])
B = int(hoge[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, max(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 = [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());print(max(a*b,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(" ")]
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):
import sys
MAX_INT = int(10e10)
MIN_INT = -MAX_INT
mod = 1000000007
sys.setrecursionlimit(1000000)
def IL(): return list(map(int,input().split()))
def SL(): return input().split()
def I(): return int(sys.stdin.readline())
def S(): return input()

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

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

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

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

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

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

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

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

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

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

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

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

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

Solution (Python):



import sys

input = sys.stdin.readline

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

main()

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

main()

Solution (Python):

import sys
input = sys.stdin.readline
sys.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())
ans = max(A+B,A-B)
ans = max(ans,A*B)
print(ans)

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

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

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

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

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

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


num1 = A + B
num2 = A - B
num3 = A * B

print(max(num1, num2, num3))

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

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(_) for _ in input().split())
print(max(a+b, a-b, a*b))

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

print(max(x+y, x-y, x*y))

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

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

m = max(a+b, a-b)

print(max(m, a*b))

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


main()

Solution (Python):
from sys import stdin


a,b = [int(x) for x in stdin.readline().rstrip().split()]


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

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

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

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

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

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

Solution (Python):
from sys import stdin

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

input = lambda: stdin.readline()
main()

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


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


if __name__ == "__main__":
    main()

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

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

Solution (Python):


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

Solution (Python):
INF = 10**12
MOD = 10**9 + 7
a, b = [int(item) for item 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 =  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
import collections
import copy
import math
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())

print(max((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 math
import copy
from operator import mul
from functools import reduce
from collections import defaultdict
from collections import Counter
from collections import deque

from itertools import product

from itertools import permutations

from itertools import combinations

from itertools import accumulate
from bisect import bisect_left, bisect_right

import re







def inside(y, x, H, W):
    return 0 <= y < H and 0 <= x < W


dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
 
def i_inpl(): return int(input())
def l_inpl(): return list(map(int, input().split()))
def line_inpl(x): return [i_inpl() for _ in range(x)]

INF = int(1e30)
MOD = int(1e9)+7 


def create_grid(H, W, value = 0):
    return [[ value for _ in range(W)] for _ in range(H)]



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

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

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

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

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

Solution (Python):

a, b = [int(el) for el 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 numpy as np
import math
import sys
sys.setrecursionlimit(10000000)

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

print(t)

Solution (Python):


import math
import sys
import itertools
import numpy as np


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


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().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 =[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):
import sys,collections as cl,bisect as bs
sys.setrecursionlimit(100000)
mod = 10**9+7
Max = sys.maxsize
def l(): 
    return list(map(int,input().split()))
def m(): 
    return map(int,input().split())
def onem(): 
    return int(input())
def s(x): 
    a = []
    aa = x[0]
    su = 1
    for i in range(len(x)-1):
        if aa == x[i+1]:
            a.append([aa,su])
            aa = x[i+1]
            su = 1
        else:
            su += 1
    a.append([aa,su])
    return a
def jo(x): 
    return " ".join(map(str,x))
def max2(x): 
    return max(map(max,x))

a,b = l()

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