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

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

input = sys.stdin.buffer.readline
in_n = lambda: int(input())
in_nn = lambda: map(int, input().split())
in_s = lambda: input().rstrip().decode('utf-8')
in_map = lambda: [s == ord('.') for s in input() if s != ord('\n')]

MOD = 10**9 + 7
INF = 8 * 10**18


def main():
    a, b = in_nn()
    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):
lst = input().split()
a = int(lst[0])
b = int(lst[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())

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

print(max(A))

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

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

print(max(A))

Solution (Python):
def mapt(fn, *args):
    return tuple(map(fn, *args))


def Input():
    return mapt(int, input().split(" "))


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

main()

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

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

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

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

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

a=A+B
b=A-B
c=A*B

print(max(a,b,c))

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

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

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

Solution (Python):
import sys


def input(): return sys.stdin.readline().strip()
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return input()
def LS(): return input().split()


INF = float('inf')


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


if __name__ == '__main__':
    main()

Solution (Python):
def LI():
    return list(map(int, input().split()))


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

Solution (Python):
import sys
def MI(): return map(int,sys.stdin.readline().rstrip().split())


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

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

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

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

Solution (Python):
A, B = map(int,input().split())
print(max(A+B, 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**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return map(int,sys.stdin.readline().rstrip().split())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))  
def LI2(): return list(map(int,sys.stdin.readline().rstrip()))  
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())  
def LS2(): return list(sys.stdin.readline().rstrip())  


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

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

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

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

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

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

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

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

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

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

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

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


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys

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


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

    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())
print(max(A+B, 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().rstrip().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())
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=input().split()
a=int(a)
b=int(b)
ls=[a+b,a-b,a*b]
ls.sort()
print(ls[2])

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

Solution (Python):
a=input();print(max(eval(a.replace(" ",k))for k in"+-*"))

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

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

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

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

print(max(s, t, w))

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

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

Solution (Python):


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

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

Solution (Python):
a, b = map(int, input().split())
c = []
c.append(a+b)
c.append(a-b)
c.append(a*b)
c = sorted(c, reverse=True)
print(c[0])

Solution (Python):
import sys


stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))


def main():
    a, b = nm()
    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 = (int (x) for x in input ().split ())
x = a+b
y = a-b
z = a*b
if x>=y and x>=z:
  print (x)
elif y>=x and y>=z:
  print (y)
else:
  print (z)

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

Solution (Python):
import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


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

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

    return


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


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

read = sys.stdin.read
readline = sys.stdin.buffer.readline
sys.setrecursionlimit(10 ** 8)
INF = float('inf')
MOD = 10 ** 9 + 7


def main():
    A, B = map(int, readline().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())
print(max(a + b, 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
if x>=y and x>=z:
    print(x)
elif y>=x and y>=z:
    print(y)
else:
    print(z)

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

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

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

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

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

Solution (Python):

















import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
from itertools import accumulate, permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left
from fractions import gcd
from heapq import heappush, heappop
from functools import reduce
import numpy as np
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7

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

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

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

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

Solution (Python):


import math

import itertools
from collections import deque
from collections import Counter
import heapq
from fractions  import gcd


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

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

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

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

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

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

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

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

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

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

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

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

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

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

ans = []

ans.append(A+B)
ans.append(A-B)
ans.append(A*B)

print(max(ans))

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

print(max(A+B,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):
a,b = map(int,input().split())
print(max(a+b,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
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines

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

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

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

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

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

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

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


if __name__ == "__main__":
    solve()

Solution (Python):
A,B=map(int,input().split())
ans=0
s1=A+B
s2=A-B
s3=A*B
if s1>=s2:
  s=s1
else:
  s=s2
if s<=s3:
  s=s3
print(s)

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

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

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

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

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

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

Solution (Python):
import sys
import math
import itertools
import collections
import heapq
import re
import numpy as np

rr = lambda: sys.stdin.readline().rstrip()
rs = lambda: sys.stdin.readline().split()
ri = lambda: int(sys.stdin.readline())
rm = lambda: map(int, sys.stdin.readline().split())
rl = lambda: list(map(int, sys.stdin.readline().split()))
inf = float('inf')
mod = 10**9 + 7

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

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

if not (-1000 <= A <= 1000 and -1000 <= B <= 1000):
    sys.exit()

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

print(result)

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

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

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


import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return


def main():
    a, b = read_list(int)
    print(max([a + b, a - b, a * b]))


if __name__ == "__main__":
    main()

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

Solution (Python):
import sys
def input(): return sys.stdin.readline().strip()


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

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

a = [AB_add, AB_dec, AB_mul]

a.sort()

print(a[2])

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

pl = a + b
mi = a - b
ml = a * b
l = sorted([pl, mi, ml])

print(l[-1])

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

Solution (Python):
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7

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

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

import sys


def solve(A: int, B: int):
    return 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))  
    print(solve(A, B))

def test():
    import doctest
    doctest.testmod()

if __name__ == '__main__':
    
    main()

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

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

Solution (Python):

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


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

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

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

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

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

Solution (Python):
a,b = 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())
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())
x = []

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

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

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

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

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

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



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

print(max(l))

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

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

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

print(max(X))

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

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

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

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

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

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

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

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

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

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

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

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):
from sys import stdin

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

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

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

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

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

Solution (Python):

import sys
input = sys.stdin.readline









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

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

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

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

Solution (Python):


import sys






























def main():
    mod = 1000000007                
    inf = float('inf')              
    
    sys.setrecursionlimit(10**6)    
    def input(): return sys.stdin.readline().rstrip()
    def ii():    return int(input())
    def mi():    return map(int, input().split())
    def mi_0():  return map(lambda x: int(x)-1, input().split())
    def lmi():   return list(map(int, input().split()))
    def lmi_0(): return list(map(lambda x: int(x)-1, input().split()))
    def li():    return list(input())
    
    
    a, b = mi()
    print(max(a + b, a - b, a * b))


if __name__ == "__main__":
    main()

Solution (Python):
x = input().split()
a = int(x[0])
b = int(x[1])
l = [a+b, a-b, a*b]
print(sorted(l, reverse=True)[0])

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

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

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

compare.append(A+B)
compare.append(A-B)
compare.append(A*B)

print(max(compare))

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

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