#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string>
#include <cctype>

using namespace std;

typedef unsigned long long L;

int n,m;
int map[2222][2222];

int p[2222][2222];
int p2[2222][2222];
int TX[2222][2222];

bool match(int d, int &x)
{
    if(x==1<<20 || x==d) {
        x = d;
        return true;
    } else {
        x = d;
        return false;
    }
}

void dod(int G)
{
    // diagonal same
    for(int i=0; i < m+n+1; ++i) {
        int same;
        for(int j = 0; j < m; ++j) {
            if(i-j < 0 || i-j >= n)
                continue;

            if(j>0 && map[i-j][j] == map[i-(j-1)][j-1])
                same++;
            else
                same = 1;
            p[i-j][j] = same;
        }
    }

    // vertical asc (rev)
    for(int j=0; j<m; ++j) {
        int ok;
        int X = 1<<20;
        for(int i = n-1; i >= 0; --i) {
            if(i < n-1 && match(map[i][j] - map[i+1][j], X)) {
                ok = min(ok+1, p[i][j]);
            } else {
                ok = 1;
            }

            p2[i][j] = ok;
            TX[i][j] = X;
        }
    }
    // horizontal asc
    for(int i=0; i<n; ++i) {
        int ok;
        int X = 1<<20;
        for(int j = 0; j < m; ++j) {
            if(j > 0 && match(map[i][j] - map[i][j-1], X)) {
                ok = min(ok+1, p[i][j]);
            } else {
                ok = 1;
            }

            if(TX[i][j] != -X)
                continue;
            int t = min(ok, p2[i][j]);
            if(t >= G)
                throw true;
        }
    }
}

void doh(int G)
{
    // horizontal same
    for(int i=0; i < n; ++i) {
        int same;
        for(int j = 0; j < m; ++j) {
            if(j>0 && map[i][j] == map[i][j-1])
                same++;
            else
                same = 1;
            p[i][j] = same;
        }
    }
    // vertical
    for(int j=0; j<m; ++j) {
        int ok = 1;
        int X = 1<<20;
        for(int i = 0; i < n; ++i) {
            if(i > 0 && match(map[i][j] - map[i-1][j], X)) {
                if(p[i][j] >= G) 
                    ok++;
                else {
                    ok = 0;
                    X = 1<<20;
                }
            } else {
                if(p[i][j] >= G) 
                    ok = 1;
                else
                    ok = 0;
                X = 1<<20;
            }

            if(ok >= G)
                throw true;
        }
    }
}


void dov(int G)
{
    // vertical same
    for(int j=0; j < m; ++j) {
        int same;
        for(int i = 0; i < n; ++i) {
            if(i>0 && map[i][j] == map[i-1][j])
                same++;
            else
                same = 1;
            p[i][j] = same;
        }
    }
    // horizontal
    for(int i=0; i<n; ++i) {
        int ok = 1;
        int X = 1<<20;
        for(int j = 0; j < m; ++j) {
            if(j > 0 && match(map[i][j] - map[i][j-1], X)) {
                if(p[i][j] >= G)
                    ok++;
                else {
                    ok = 0;
                    X = 1<<20;
                }
            } else {
                if(p[i][j] >= G)
                    ok = 1;
                else {
                    ok = 0;
                }
                X = 1<<20;
            }

            if(ok >= G)
                throw true;
        }
    }
}

int main()
{
    while(cin >> n >> m && n && m) {
        for(int i=0; i < n; ++i) {
            for(int j=0; j < m; ++j)
                scanf("%d", map[i]+j);
        }

        int mi=1, ma=min(n,m)+1;
        while (ma > 1+mi) {
            int t = (mi+ma)/2;
            try {

                doh(t);

                dov(t);

                dod(t);

                for(int i = 0; i < n; ++i) {
                    for(int j = 0; j < m/2; ++j)
                        swap(map[i][j], map[i][m-1-j]);
                }
                dod(t);

                for(int j = 0; j < m; ++j) {
                    for(int i = 0; i < n/2; ++i)
                        swap(map[i][j], map[n-1-i][j]);
                }
                dod(t);

                for(int i = 0; i < n; ++i) {
                    for(int j = 0; j < m/2; ++j)
                        swap(map[i][j], map[i][m-1-j]);
                }
                dod(t);

                ma = t;
            }
            catch(bool) {
                mi = t;
            }
        }

        cout << mi*mi << endl;
    }


    return 0;
}