// #pragma GCC target("avx2")  // CPU 処理並列化
// #pragma GCC optimize("O3")  // CPU 処理並列化
// #pragma GCC optimize("unroll-loops")  // 条件処理の呼び出しを減らす
#include<stdio.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<deque>
#include<stack>
#include<string>
#include<string.h>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<stdlib.h>
#include<cassert>
#include<time.h>
#include<bitset>
#include<numeric>
using namespace std;
const long long mod=998244353;
const long long inf=mod*mod;
const long long d2=(mod+1)/2;
const double EPS=1e-10;
const double INF=1e+10;
const double PI=acos(-1.0);
const int C_SIZE = 3121000;
long long fact[C_SIZE];
long long finv[C_SIZE];
long long inv[C_SIZE];
long long Comb(int a,int b){
 	if(a<b||b<0)return 0;
 	return fact[a]*finv[b]%mod*finv[a-b]%mod;
}
void init_C(int n){
	fact[0]=finv[0]=inv[1]=1;
	for(int i=2;i<n;i++){
		inv[i]=(mod-(mod/i)*inv[mod%i]%mod)%mod;
	}
	for(int i=1;i<n;i++){
		fact[i]=fact[i-1]*i%mod;
		finv[i]=finv[i-1]*inv[i]%mod;
	}
}
long long pw(long long a,long long b){
	if(a<0LL)return 0;
	if(b<0LL)return 0;
	long long ret=1;
	while(b){
		if(b%2)ret=ret*a%mod;
		a=a*a%mod;
		b/=2;
	}
	return ret;
}
int ABS(int a){return max(a,-a);}
long long ABS(long long a){return max(a,-a);}
double ABS(double a){return max(a,-a);}
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
// ここから編集しろ
int p[110][110];
int ret[2][110][110];
int cnt[110][110];
int used[110][110];
 
int used2[110][110];
pair<int,pair<int,int> >ev[11000];
vector<int>v[110][110];


const int D_MAX_V=212;
const int D_v_size=212;
struct D_wolf{
	int t,c,r;
	D_wolf(){t=c=r=0;}
	D_wolf(int t1,int c1,int r1){
		t=t1;c=c1;r=r1;
	}
};
vector<D_wolf>D_G[D_MAX_V];
int D_level[D_MAX_V];
int D_iter[D_MAX_V];

void add_edge(int from,int to,int cap){
	D_G[from].push_back(D_wolf(to,cap,D_G[to].size()));
	D_G[to].push_back(D_wolf(from,0,D_G[from].size()-1));
}
void D_bfs(int s){
	for(int i=0;i<D_v_size;i++)D_level[i]=-1;
	queue<int> Q;
	D_level[s]=0;
	Q.push(s);
	while(Q.size()){
		int v=Q.front();
		Q.pop();
		for(int i=0;i<D_G[v].size();i++){
			if(D_G[v][i].c>0&&D_level[D_G[v][i].t]<0){
				D_level[D_G[v][i].t]=D_level[v]+1;
				Q.push(D_G[v][i].t);
			}
		}
	}
}
int D_dfs(int v,int t,int f){
	if(v==t)return f;
	for(;D_iter[v]<D_G[v].size();D_iter[v]++){
		int i=D_iter[v];
		if(D_G[v][i].c>0&&D_level[v]<D_level[D_G[v][i].t]){
			int d=D_dfs(D_G[v][i].t,t,min(f,D_G[v][i].c));
			if(d>0){
				D_G[v][i].c-=d;
				D_G[D_G[v][i].t][D_G[v][i].r].c+=d;
				return d;
			}
		}
	}
	return 0;
}
int max_flow(int s,int t){
	int flow=0;
	for(;;){
		D_bfs(s);
		if(D_level[t]<0)return flow;
		for(int i=0;i<D_v_size;i++)D_iter[i]=0;
		int f;
		while((f=D_dfs(s,t,99999999))>0){flow+=f;}
	}
	return 0;
}

int main(){
	int a,b;scanf("%d%d",&a,&b);
	for(int i=0;i<a;i++)for(int j=0;j<b;j++){
		scanf("%d",&p[i][j]);p[i][j]--;
	}
	for(int i=0;i<a;i++)for(int j=0;j<b;j++){
		cnt[i][p[i][j]/b]++;
		v[i][p[i][j]/b].push_back(p[i][j]);
	}
	for(int i=0;i<b;i++){
		for(int j=0;j<D_MAX_V;j++)D_level[j]=D_iter[j]=0;
		for(int j=0;j<D_MAX_V;j++)D_G[j].clear();
		int si=a*2;
		int ti=a*2+1;
		for(int j=0;j<a;j++){
			for(int k=0;k<a;k++){
				add_edge(j,k+a,cnt[j][k]);
			}
			add_edge(si,j,1);
			add_edge(j+a,ti,1);
		}
		max_flow(si,ti);
		vector<pair<int,int> > tt;
		for(int j=0;j<a;j++){
			for(int k=0;k<D_G[j].size();k++){
				int to=D_G[j][k].t;
				if(a<=to&&to<a*2&&D_G[j][k].c<cnt[j][to-a]){
					tt.push_back(make_pair(j,to-a));	
				}
			}
		}
		for(int j=0;j<tt.size();j++){
			int L=tt[j].first;
			int R=tt[j].second;
			ret[0][L][i]=v[L][R][cnt[L][R]-1];
			cnt[L][R]--;
		}
	}
	for(int i=0;i<a;i++){
		for(int j=0;j<b;j++){
			if(j)printf(" ");
			printf("%d",ret[0][i][j]+1);
		}
		printf("\n");
	}
	for(int i=0;i<b;i++){
		vector<int>tmp;
		for(int j=0;j<a;j++){
			tmp.push_back(ret[0][j][i]);
		}
		std::sort(tmp.begin(),tmp.end());
		for(int j=0;j<a;j++)ret[1][j][i]=tmp[j];
	}
	for(int i=0;i<a;i++){
		for(int j=0;j<b;j++){
			if(j)printf(" ");
			printf("%d",ret[1][i][j]+1);
		}
		printf("\n");
	}
}

Measured memory_bytes: 1408