#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>

#define ll long long
#define P pair<int, int>
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define LAST(x) (x)[(x).size() - 1]
#define GI(name) \
    int(name);   \
    scanf("%d", &(name))
#define GI2(name1, name2) \
    int(name1), (name2);  \
    scanf("%d %d", &(name1), &(name2))
#define GI3(name1, name2, name3)  \
    int(name1), (name2), (name3); \
    scanf("%d %d %d", &(name1), &(name2), &(name3))
#define GVI(name, size)      \
    vector<int>(name)(size); \
    FOR(i, (size))           \
    scanf("%d", &(name)[i])

using namespace std;

string to_hex(int x)
{
    stringstream ss;
    ss << hex << x;
    return ss.str();
}

inline int get_int()
{
    int ret;
    scanf("%d", &ret);
    return ret;
}

inline vector<int> get_ints(int n)
{
    vector<int> ret(n);
    FOR(i, n)
    {
        scanf("%d", &ret[i]);
    }
    return ret;
}

inline string get_str()
{
    string ret;
    cin >> ret;
    return ret;
}

bool is_prime(int n)
{
    int s = sqrt(n) + 1;
    for (int i = 2; i <= s; ++i)
    {
        if (n % i == 0)
        {
            return 0;
        }
    }
    return 1;
}

vector<P> prime_division(int n)
{
    vector<P> ret;
    int s = sqrt(n) + 1;
    int c = 0;
    for (int i = 2; i <= s; ++i)
    {
        if (n % i == 0)
        {
            c = 0;
            do
            {
                ++c;
                n /= i;
            } while (n % i == 0);
            ret.push_back(P(i, c));
        }
    }
    return ret;
}

string to_string(string s)
{
    return s;
}

template <class T>
string to_string(vector<T> v)
{
    string ret = "{";
    FOR(i, v.size() - 1)
    {
        ret += to_string(v[i]) + ",";
    }
    if (v.size() > 0)
    {
        ret += to_string(LAST(v));
    }
    ret += "}";
    return ret;
}

void debug_print()
{
    cerr << endl;
}

template <class Head, class... Tail>
void debug_print(Head head, Tail... tail)
{
    cerr << to_string(head) << " ";
    debug_print(tail...);
}

template <class... T>
void debug(T... args)
{
    cerr << "[" << __LINE__ << "]: ";
    debug_print(args...);
}

void print()
{
    cout << endl;
}

template <class Head, class... Tail>
void print(Head head, Tail... tail)
{
    cout << to_string(head);
    print(tail...);
}

int main()
{
    GI2(H, W);
    if (H % 3 == 0 || W % 3 == 0)
    {
        print(0);
    }
    else
    {
        ll list[4]={};
        FOR(i, 2)
        {
            ll d1 = ceil(H / (float)3);
            ll r1 = d1 * W;
            ll d2 = H - d1;
            ll d3 = W / 2;
            ll r2 = d2 * d3;
            ll r3 = d2 * (W - d3);
            list[i]=max({abs(r1 - r2), abs(r2 - r3), abs(r3 - r1)});
            swap(H,W);
        }
        FOR(i, 2)
        {
            ll d1 = floor(H / (float)3);
            ll r1 = d1 * W;
            ll d2 = H - d1;
            ll d3 = W / 2;
            ll r2 = d2 * d3;
            ll r3 = d2 * (W - d3);
            list[i+2]=max({abs(r1 - r2), abs(r2 - r3), abs(r3 - r1)});
            swap(H,W);
        }
        FOR(i, 2)
        {
            ll d1 = ceil(H / (float)3);
            ll r1 = d1 * W;
            ll d2 = (H-d1)/2;
            ll d3=H-d1-d2;
            ll r2=d2*W;
            ll r3=d3*W;
            list[i+4]=max({abs(r1 - r2), abs(r2 - r3), abs(r3 - r1)});
            swap(H,W);
        }
        FOR(i, 2)
        {
            ll d1 = floor(H / (float)3);
            ll r1 = d1 * W;
            ll d2 = (H-d1)/2;
            ll d3=H-d1-d2;
            ll r2=d2*W;
            ll r3=d3*W;
            list[i+6]=max({abs(r1 - r2), abs(r2 - r3), abs(r3 - r1)});
            swap(H,W);
        }
        print(*min_element(list,list+8));
    }
    return 0;
}


Measured memory_bytes: 256