# define _SCL_SECURE_NO_WARNINGS

# include <iostream>
# include <string>
# include <iomanip>
# include <stdio.h>
# include <array>
# include <numeric>
# include <algorithm>
# include <vector>
# include <functional>
# include <fstream>
# include <random>
# include <bitset>




using Ull = unsigned long long;
using Ll = long long;


namespace
{

    template<typename T>
    std::istream& operator >> (std::istream& is, std::vector<T>& vec)
    {
        for (T& x : vec) is >> x;
        return is;
    }

    template<typename T>
    std::string to_string(std::vector<T> vec, std::string sep = " ")
    {
        std::string result;
        for (T& x : vec) result += std::to_string(x) + sep;
        result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L>
    std::string to_string(T(&ary)[L], std::string sep = " ", size_t size = L)
    {
        std::string result;
        for (int i = 0; i < size; ++i) result += std::to_string(ary[i]);
        result.erase(result.size() - sep.length());

        return result;
    }

    template<typename T, size_t L, typename Function>
    void for_each(T(&ary)[L], Function lambda)
    {
        for (size_t i{}; i < L; ++i)
            lambda(static_cast<T&>(ary[i]));
    }

    template<typename T>
    void SetAll(T container, typename T::value_type value = typename T::value_type{})
    {
        for (typename T::reference content : container)
            content = value;
    }

    template<typename T, size_t L>
    void SetAll(T(&ary)[L], T value = T{})
    {
        for (size_t i{}; i < L; ++i)
            ary[i] = value;
    }

    template<typename T, size_t L>
    std::array<T, L> AsContainer(T(&ary)[L], bool isSwap = true)
    {
        std::array<T, L> result;

        if (isSwap)
        {
            for (size_t i{}; i < L; ++i)
                std::swap(result[i], ary[i]);
        }
        else
        {
            for (size_t i{}; i < L; ++i)
                result[i] = ary[i];
        }

        return result;
    }

    template<size_t length>
    constexpr std::array<size_t, length> range()
    {
        std::array<size_t, length> range{};

        for (size_t i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T length)
    {
        std::vector<T> range(length);

        for (T i{}; i < length; ++i)
            range[i] = i;

        return range;
    }

    template<typename T>
    const std::vector<T> range(const T start, const T end)
    {
        if (start >= end) return std::vector<T>{};

        std::vector<T> range(end - start);

        for (T i{start}; i < end; ++i)
            range[i - start] = i;

        return range;
    }

    bool IsPrime(const Ull n)
    {
        switch (n)
        {
        case 0: case 1:
            return false;
        case 2:
            return true;
        default:

            if (n % 2 == 0) return false;

            for (Ull i{3}; i * i <= n; i += 2)
            {
                if (n % i == 0) return false;
            }
        }

        return true;
    }

    // 最大公約数
    int EuclideanAlg(int n1, int n2)
    {
        if (n1 < 0 || n2 < 0) return 0;
        if (n2 > n1) std::swap(n1, n2);

        int r;
        while ((r = n1 % n2) != 0)
        {
            n1 = n2;
            n2 = r;
        }

        return n2;
    }

    // 最小公倍数
    Ull LCM(const std::vector<Ull>& values)
    {
        if (values.size() == 0)
            return 0;
        if (values.size() == 1)
            return values[0];
        if (values.size() == 2)
            return values[0] * values[1] / EuclideanAlg(values[0], values[1]);

        auto mid = values.cbegin() + values.size() / 2;

        return LCM(std::vector<Ull>{LCM(std::vector<Ull>(values.begin(), mid)), LCM(std::vector<Ull>(mid, values.end()))});
    }


    void Solve();
}

# if true
int main()
{
    Solve();
    return 0;
}
# endif

namespace
{
    void Solve()
    {
        int A, B;
        std::cin >> A >> B;

        int result = std::max(A + B, A - B);
        std::cout << std::max(A * B, result);
    }
}

Measured memory_bytes: 256