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):
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush
from fractions import gcd
from copy import deepcopy
import math
Mod = 1000000007



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




def sieve_of_eratosthenes(n):
    if not isinstance(n,int):
        raise TypeError("n is not int")
    if n<2:
        raise ValueError("n < 2 is not effective")
    prime = [1]*(n+1)
    for i in range(2,int(math.sqrt(n))):
        if prime[i] == 1:
            for j in range(2*i,n):
                if j%i == 0:
                    prime[j] = 0
    res = []
    for i in range(2,n):
        if prime[i] == 1:
            res.append(i)
    return res

class UnionFind:
    def __init__(self,n):
        self.parent = [i for i in range(n+1)]
        self.rank = [0 for i in range(n+1)]
    
    def findroot(self,x):
        if x == self.parent[x]:
            return x
        else:
            y = self.parent[x]
            y = self.findroot(self.parent[x])
            return y
    
    def union(self,x,y):
        px = self.findroot(x)
        py = self.findroot(y)
        if px < py:
            self.parent[py] = px
        else:
            self.parent[px] = py

    def same_group_or_no(self,x,y):
        return self.findroot(x) == self.findroot(y)

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

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):
import sys, math, itertools, bisect, copy, re
from collections import Counter, deque, defaultdict






INF = float('inf')
MOD = 10 ** 9 + 7
EPS = 10 ** -7
sys.setrecursionlimit(1000000)









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

from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
from functools import reduce
import sys
import math
import bisect
import random
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return list(map(float, sys.stdin.readline().split()))
def LS():return sys.stdin.readline().split()
def SR(n): return [list(sys.stdin.readline())[:-1] for i in range(n)]
def IR(n): return [int(sys.stdin.readline()) for i in range(n)]
def LIR(n): return [list(map(int, sys.stdin.readline().split())) for i in range(n)]
def LSR(n): return [list(map(list, sys.stdin.readline().split())) for i in range(n)]
_gcd = lambda x, y: _gcd(y, x%y) if (x%y) else y
_lcm = lambda x, y: x*y // _gcd(x, y)
def gcd(*numbers):
    return reduce(_gcd, numbers)
def lcm(*numbers):
    return reduce(_lcm, numbers)
sys.setrecursionlimit(1000000)
INF = float('inf')
mod = 1000000007
dire4 = [(1,0), (0,1), (-1,0), (0,-1)]
dire8 = [(1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0), (-1, -1), (0, -1), (1, -1)]


A, B = LI()

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

import sys
INF = float("inf")


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


def main():

    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    A = int(next(tokens))  
    B = int(next(tokens))  
    solve(A, B)


if __name__ == '__main__':
    main()

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

sys.setrecursionlimit(4100000)


def inputs(num_of_input):
    ins = [input() for i in range(num_of_input)]
    return ins


def solve(inputs):
    [A, B] = string_to_int(inputs[0])
    ret = []
    ret.append(A+B)
    ret.append(A-B)
    ret.append(A*B)
    return max(ret)


def string_to_int(string):
    return list(map(lambda x: int(x), string.split()))


if __name__ == "__main__":
    ret = solve(inputs(1))
    print(ret)

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


tasu=a+b
hiku=a-b
kake=a*b

print(max(tasu, hiku, kake))

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

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

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

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

if __name__ == '__main__':
	main()

Solution (Python):

import sys
import math
from collections import defaultdict


sys.setrecursionlimit(10**7)


mod = 10**9 + 7


def I(): return int(input())
def II(): return map(int, input().split())
def III(): return list(map(int, input().split()))
def Line(N):
  read_all = [tuple(map(int, input().split())) for _ in range(N)]
  return map(list,zip(*read_all))



A,B = II()

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

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

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

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

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

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

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

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

Solution (Python):



import sys
import math
import bisect
sys.setrecursionlimit(1000000000)
from heapq import heappush, heappop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))

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

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

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

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


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

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

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

Solution (Python):
a,b=map(int,input().split())
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())
A=[a+b,a-b,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 = [int(i) for i in input().split()]


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

Solution (Python):



import array
from bisect import *
from collections import *
import fractions
import heapq
from itertools import *
import math
import random
import re
import string
import sys

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

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

Solution (Python):
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)

def s(generator, splitter, mapper):
    return [ mapper(s) for s in generator().split(splitter) ]


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


def get_nums_n(n):
    return [ int(input()) for _ in range(n)]

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

Solution (Python):
import bisect
import heapq
import itertools
import math
import operator
import os
import re
import string
import sys
from collections import Counter, deque, defaultdict
from copy import deepcopy
from decimal import Decimal
from fractions import gcd
from functools import lru_cache, reduce
from operator import itemgetter, mul, add, xor

import numpy as np

if os.getenv("LOCAL"):
    sys.stdin = open("_in.txt", "r")

sys.setrecursionlimit(2147483647)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7


A, B = list(map(int, 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 itertools
from collections import Counter
from collections import defaultdict
from collections import deque
import bisect
from heapq import heappush, heappop

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