#include <iostream>
#include <algorithm>
#include <stack>


using namespace std;

struct trio{
    int x;
    int y;
    int size;
};

struct figure {
    int** rectangle;
    int delivered;
    int N, M;
    int minCount;
    stack <trio> coordinates;
} figure;

stack<pair<int, bool>> size_square;


void max_insert(int x, int y)
{
    int size;
    for (size = 1; size <= figure.N - 1; size++)
    {
        if (y + size > figure.N)
            return;

        if (x + size > figure.M)
            return;

        for (int i = y; i < y + size; i++)
            for (int j = x; j < x + size; j++)
            {
                if (figure.rectangle[i][j] != 0)
                    return;
            }
        size_square.push(make_pair(size, false));
    }
}


void clear(trio a)
{
    figure.delivered -= a.size * a.size;

    for (int i = a.y; i < a.y + a.size; i++)
        for (int j = a.x; j < a.x + a.size; j++)
            figure.rectangle[i][j] = 0;
}


void insert(int x, int y, int size, int color)
{
    figure.delivered += size * size;

    for (int i = y; i < y + size; i++)
        for (int j = x; j < x + size; j++)
            figure.rectangle[i][j] = color;
}


void print(){
    for (int i = 0; i < figure.N; i++) {
        for (int j = 0; j < figure.M; j++) {
            cout << figure.rectangle[i][j] << ' ';
        }
        cout << endl;
    }
    cout << endl;
    getchar();
}


int tiling(int try_insert)
{
    int x = 0, y = 0;
    int color = 1;
    int counter = 1;
    bool flag;

    max_insert(x, y);
    insert(x, y, size_square.top().first, color);
    size_square.top().second = true;

    figure.coordinates.push(trio{x, y, size_square.top().first});
    color++;


    while (!size_square.empty())
    {
        size_square.top().second = true;


        flag = false;
        for (y = 0; y < figure.N; y++) {
            for (x = 0; x < figure.M; x++)
            {
                if (figure.rectangle[y][x] == 0)
                {
                    flag = true;
                    max_insert(x, y);
                    insert(x, y, size_square.top().first, color);
                    figure.coordinates.push(trio{x, y, size_square.top().first});
                    counter++;
                    color++;
//                    cout << "Insert (" << figure.minCount << ')' << endl;
//                    print();
                    break;
                }
            }
            if (flag)
                break;
        }
        if (figure.delivered == figure.N * figure.M || counter >= figure.minCount)
        {
            if (counter < figure.minCount){
                figure.minCount = counter;
            }
            //recovery
        }
        while (!size_square.empty() && size_square.top().second)
        {
            size_square.pop();
            clear(figure.coordinates.top());
            figure.coordinates.pop();
            if (!size_square.empty() && !size_square.top().second){
                bool ps = false;
                for (y = 0; y < figure.N && !ps; y++)
                    for (x = 0; x < figure.M && !ps; x++)
                        if (figure.rectangle[y][x] == 0)
                        {
                            ps = true;
                            figure.coordinates.push(trio{x, y, size_square.top().first});
                            insert(x, y, size_square.top().first, color);
                            counter = figure.coordinates.size();
                        }
            }
            color++;
        }
    }

    return figure.minCount;
}


int main() {
    int try_insert = 4;
    int flag = true;
    cin >> figure.N >> figure.M;

    if (figure.N > figure.M)
    {
        swap(figure.N, figure.M);
    }

    figure.rectangle = new int*[figure.N];
    figure.minCount = figure.M*figure.N+1;
    for (int i = 0; i < figure.N; i++)
    {
        figure.rectangle[i] = new int[figure.M];
    }

    for (int i = 0; i < figure.N; i++)
        for (int j = 0; j < figure.M; j++)
            figure.rectangle[i][j] = 0;

//    while (flag)
//    {
//        flag = tiling(try_insert);
//        try_insert++;
//    }
    cout << tiling(try_insert) << endl;

//    print();

    return 0;
}