#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;
    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();
}



pair<int, int> tiling()
{
    int x = 0, y = 0;
    int color = 1;
    int number_colorings = 0;
    int number_squares = figure.N * figure.M + 1;
    bool flag;

    max_insert(x, y);

    do{
        flag = false;

        for (y = 0; y < figure.N; y++) {
            for (x = 0; x < figure.M; x++)
            {
                if (figure.rectangle[y][x] == 0)
                {
                    flag = true;

                    if (size_square.top().second == true)
                        max_insert(x, y);

                    insert(x, y, size_square.top().first, color);
                    figure.coordinates.push(trio{x, y, size_square.top().first});
                    size_square.top().second = true;

                    color++;
                    //cout << "Insert"<< endl;
                    //print();
                    break;
                }
            }
            if (flag)
                break;
        }

        if (  color - 1 == number_squares && figure.delivered != figure.M * figure.N)
        {
            while ( !size_square.empty() && size_square.top().second)
            {
                size_square.pop();
                clear(figure.coordinates.top());
                figure.coordinates.pop();
                color--;

                //cout << "Dell"<< endl;
                //print();
            }
        }

        if ( !size_square.empty() && figure.delivered == figure.M * figure.N)
        {
            if (number_squares == color - 1)
            {
                number_colorings++;
            } else{
                number_squares = color - 1;
                number_colorings = 1;
            }


            while ( size_square.top().second )
            {
                size_square.pop();
                clear(figure.coordinates.top());
                figure.coordinates.pop();
                color--;

                //cout << "Dell"<< endl;
                //print();
            }
        }
    }while (!size_square.empty());

    return make_pair(number_squares, number_colorings);
}



int main() {
    pair <int, int> ans;
    cin >> figure.N >> figure.M;

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

    figure.rectangle = new int * [figure.N];

    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;
        }

    ans = tiling();

    cout << "Minimum number of squares: " << ans.first << endl
         << "Number of minimum constellations: " << ans.second;

    return 0;
}