#include <bits/stdc++.h>

using namespace std;

const int N = 500 + 3;
const int M = 5 + 3;
const int T = 32 + 3;
const int STATES = 500 * 32 + 3;

int n, m;
int ans[N][N], a[N][M];

template<class T>
void check_min(T &a, T b){ a = (a < b) ? a : b; }

vector<int> adj[STATES];

bool check(int i, int state, int j){
    for(int k = 0; k < 5; ++k){
        if(state >> k & 1){
            if(a[i][k] != a[j][k])
                return false;
        }
    }
    return true;
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    cin >> n >> m;
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < m; ++j){
            cin >> a[i][j];
            --a[i][j];
        }

    for(int i = 0; i < n; ++i){
        for(int state = 0; state < 32; ++state){
            for(int j = 0; j < m; ++j){
                if((state & (1 << j)))
                adj[i * 32 + state].push_back(i * 32 + (state ^ (1 << j)));
            }
            
            static bool vis[T][N];
            for(int j = 0; j < m; ++j)
                fill(vis[j], vis[j] + n, false);

            for(int j = 0; j < m; ++j){
                if(!(state >> j & 1)){
                    vis[j][a[i][j]] = true;
                    adj[i * 32 + state].push_back(i * 32 + (state ^ (1 << j)));
                }
            }

            for(int j = (i + 1) % n; j != i; j = (j + 1) % n){
                for(int k = 0; k < m; ++k){
                    if(!((state >> k) & 1) && !vis[k][a[j][k]]){
                        vis[k][a[j][k]] = true;
                        adj[i * 32 + state].push_back(j * 32 + (state ^ (1 << k)));
                    }
                }
            }

            for(int j = (i + 1) % n; j != i; j = (j + 1) % n){
                if(check(i, state, j)){
                    adj[i * 32 + state].push_back(j * 32 + state);
                    break;
                }
            }
            for(int j = (i - 1 + n) % n; j != i; j = (j - 1 + n) % n){
                if(check(i, state, j)){
                    adj[i * 32 + state].push_back(j * 32 + state);
                    break;
                }
            }
        }
    }

    const int INF = 1e9;
    for(int i = 0; i < n; ++i)
        for(int j = 0; j < n; ++j)
            ans[i][j] = INF;

    for(int i = 0; i < n; ++i){
        static int d[STATES];

        for(int j = 0; j < STATES; ++j)
            d[j] = INF;

        queue<int> q;
        for(int j = 0; j < 1; ++j){
            q.push(i * 32 + j);
            d[i * 32 + j] = 0;
        }

        int cnt = 0;
        while(!q.empty()){
            int u = q.front();
            q.pop();

            if(ans[i][u / 32] == INF){
                ++cnt;
                ans[i][u / 32] = d[u];
            }
            if(cnt == n)
                break;

            for(int to: adj[u]){
                int cand = d[u] + 1;
                if(d[to] > cand){
                    d[to] = cand;
                    q.push(to);
                }
            }
        }
    }

    for(int i = 0; i < n; ++i){
        for(int j = 0; j < n; ++j)
            cout << ans[i][j] << " ";
        cout << "\n";
    }
}