#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define all(x) (x).begin(),(x).end()
const int mod=1000000007,MAX=10305,INF=1<<30;

struct edge{int to;ll cap;int rev;};

vector<edge> G[MAX];
int level[MAX];
int iter[MAX];

void add_edge(int from,int to,ll cap){
    G[from].push_back((edge){to,cap,int(G[to].size())});
    G[to].push_back((edge){from,0LL,int(G[from].size())-1});
}

void BFS(int s){
    memset(level,-1,sizeof(level));
    queue<int> que;
    level[s] =0;
    que.push(s);
    while(!que.empty()){
        int v=que.front();que.pop();
        for(int i=0;i<G[v].size();i++){
            edge &e =G[v][i];
            if(e.cap>0&&level[e.to]<0){
                level[e.to]=level[v]+1;
                que.push(e.to);
            }
        }
    }
}

ll DFS(int v,int t,ll f){
    if(v==t) return f;
    for(int &i=iter[v];i<G[v].size();i++){
        edge &e =G[v][i];
        if(e.cap>0&&level[v]<level[e.to]){
            ll d= DFS(e.to,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.to][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
}

ll max_flow(int s,int t){
    ll flow=0;
    for(;;){
        BFS(s);
        if(level[t]<0) return flow;
        memset(iter,0,sizeof(iter));
        ll f;
        while((f=DFS(s,t,INF))>0){
            flow+=f;
        }
    }
}

int main(){
    
    std::ifstream in("text.txt");
    std::cin.rdbuf(in.rdbuf());
    cin.tie(0);
    ios::sync_with_stdio(false);
    
    int H,W;cin>>H>>W;
    vector<vector<int>> S(H,vector<int>(W));
    for(int i=0;i<H;i++){
        for(int j=0;j<W;j++){
            cin>>S[i][j];
        }
    }
    
    for(int i=10001;i<=10000+H;i++){
        add_edge(10300,i,1);
    }
    for(int i=10101;i<=10100+H;i++){
        add_edge(i,10301,1);
    }
    
    for(int i=0;i<H;i++){
        for(int j=0;j<W;j++){
            add_edge(10001+i,S[i][j],1);
            add_edge(S[i][j],10100+(S[i][j]-1)/W+1,1);
        }
    }
    
    vector<vector<int>> ans(H,vector<int>(W));
    vector<int> used(H*W+1);
    
    for(int t=0;t<W;t++){
        max_flow(10300,10301);
        
        for(int i=10001;i<=10000+H;i++){
            for(auto it:G[i]){
                if(it.cap==0&&it.to<=H*W&&used[it.to]==0){
                    ans[i-10001][t]=it.to;
                    used[it.to]=1;
                    G[it.to][it.rev].cap=0;
                }
            }
        }
        
        for(int j=0;j<G[10300].size();j++){
            auto &e=G[10300][j];
            e.cap=1;
        }
        
        for(int j=0;j<G[10301].size();j++){
            auto &e=G[10301][j];
            e.cap=0;
        }
        
        for(int i=10001;i<=10000+H;i++){
            for(int j=0;j<G[i].size();j++){
                auto &e=G[i][j];
                if(e.to==10300){
                    e.cap=0;
                }
            }
        }
        
        for(int i=10101;i<=10100+H;i++){
            for(int j=0;j<G[i].size();j++){
                auto &e=G[i][j];
                if(e.to==10301){
                    e.cap=1;
                }
            }
        }
        
    }
    
    for(int i=0;i<H;i++){
        for(int j=0;j<W;j++){
            cout<<ans[i][j]<<" ";
        }
        cout<<endl;
    }
    
    for(int j=0;j<W;j++){
        vector<int> A(H);
        for(int i=0;i<H;i++) A[i]=ans[i][j];
        sort(all(A));
        for(int i=0;i<H;i++) ans[i][j]=A[i];
    }
    
    for(int i=0;i<H;i++){
        for(int j=0;j<W;j++){
            cout<<ans[i][j]<<" ";
        }
        cout<<endl;
    }
    
}


Measured memory_bytes: 2048