#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace std;
using namespace __gnu_pbds;
 
#define fi first
#define se second
#define mp make_pair
#define pb push_back
 
typedef long long ll;
typedef pair<int,int> ii;
typedef vector<int> vi;
typedef unsigned long long ull;
typedef long double ld; 
typedef tree<ii, null_type, less<ii>, rb_tree_tag, tree_order_statistics_node_update> pbds;

int a[111][111];
int n,m; 
const int MX = 255;
const int INF = int(1e9);

struct MaxFlow //by yutaka1999, have to define INF and MX (the Max number of vertices)
{
	struct edge
	{
		int to,cap,rev;
		edge(int to=0,int cap=0,int rev=0):to(to),cap(cap),rev(rev){}
	};
	vector <edge> vec[MX];
	int level[MX];
	int iter[MX];
	
	void addedge(int s,int t,int c) //adds an edge of cap c to the flow graph
	{
		int S=vec[s].size(),T=vec[t].size();
		vec[s].push_back(edge(t,c,T));
		vec[t].push_back(edge(s,0,S));
	}
	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<vec[v].size();i++)
			{
				edge&e=vec[v][i];
				if (e.cap>0&&level[e.to]<0)
				{
					level[e.to]=level[v]+1;
					que.push(e.to);
				}
			}
		}
	}
	ll flow_dfs(int v,int t,ll f)
	{
		if (v==t) return f;
		for(int &i=iter[v];i<vec[v].size();i++)
		{
			edge &e=vec[v][i];
			if (e.cap>0&&level[v]<level[e.to])
			{
				ll d=flow_dfs(e.to,t,min(f,ll(e.cap)));
				if (d>0)
				{
					e.cap-=d;
					vec[e.to][e.rev].cap+=d;
					return d;
				}
			}
		}
		return 0;
	}
	ll maxflow(int s,int t) //finds max flow using dinic from s to t
	{
		ll flow = 0;
		while(1)
		{
			bfs(s);
			if (level[t]<0) return flow;
			memset(iter,0,sizeof(iter));
			while (1)
			{
				ll f=flow_dfs(s,t,INF);
				if(f==0) break;
				flow += f;
			}
		}
	}
};

int C[111][111];

void solve(int lx, int ly, int rx, int ry)
{
	if(lx>rx||ly>ry) return ;
	/*
	cerr<<"SOLVE: "<<lx<<' '<<ly<<' '<<rx<<' '<<ry<<'\n';
	for(int i=lx;i<=rx;i++)
	{
		for(int j=ly;j<=ry;j++)
		{
			cerr<<a[i][j]/m<<' ';
		}
		cerr<<'\n';
	}
	*/
	int cur = a[lx][ly]/m;
	//fix it in place
	vi good; int cnt=0;
	for(int j=ly;j<=ry;j++)
	{
		if(a[lx][j]/m==cur)
		{
			good.pb(a[lx][j]);
			cnt++;
		}
	}
	for(int j=ly;j<=ry;j++)
	{
		if(a[lx][j]/m!=cur) good.pb(a[lx][j]);
	}
	for(int j=ly;j<=ry;j++)
	{
		a[lx][j]=good[j-ly];
	}
	////cerr<<cnt<<'\n';
	MaxFlow mf;
	int s=MX-1; int e=MX-2;
	for(int i=lx+1;i<=rx;i++)
	{
		mf.addedge(s,i,cnt);
		for(int j=ly;j<=ry;j++)
		{
			mf.addedge(i,(a[i][j]/m)+n,1);
			//cerr<<"EDGE: "<<i<<' '<<(a[i][j]/m)+n<<'\n';
		}
	}
	for(int i=0;i<n;i++)
	{
		if(i!=(a[lx][ly]/m)) 
		{
			mf.addedge(i+n,e,cnt);
			//cerr<<"EEE: "<<i+n<<' '<<e<<'\n';
		}
	}
	int maxflw = mf.maxflow(s,e);
	assert(maxflw==cnt*(rx-lx));
	for(int i=lx+1;i<=rx;i++)
	{
		for(int j=0;j<n;j++) C[i][j]=0;
		for(auto E:mf.vec[i])
		{
			if(E.to>=n&&E.to<2*n&&E.cap==0)
			{
				//cerr<<"E: "<<i<<' '<<E.to-n<<'\n';
				C[i][E.to-n]++;
			}
		}
	}
	for(int i=lx+1;i<=rx;i++)
	{
		vi good;
		for(int j=ly;j<=ry;j++)
		{
			if(C[i][a[i][j]/m]>0)
			{
				C[i][a[i][j]/m]--;
				good.pb(a[i][j]);
				a[i][j]=-1;
			}
		}
		for(int j=ly;j<=ry;j++)
		{
			if(a[i][j]!=-1)
			{
				good.pb(a[i][j]);
			}
		}
		for(int j=ly;j<=ry;j++)
		{
			a[i][j]=good[j-ly];
		}
	}
	if(cnt==ry-ly+1)
	{
		solve(lx+1,ly,rx,ry);
	}
	else
	{
		if(ly+cnt-1<ry) solve(lx,ly,rx,ly+cnt-1);
		solve(lx,ly+cnt,rx,ry);
	}
	/*
	cerr<<"END: "<<lx<<' '<<ly<<' '<<rx<<' '<<ry<<'\n';
	for(int i=lx;i<=rx;i++)
	{
		for(int j=ly;j<=ry;j++)
		{
			cerr<<a[i][j]/m<<' ';
		}
		cerr<<'\n';
	}
	*/
}

int main()
{
	ios_base::sync_with_stdio(0); cin.tie(0);
	cin>>n>>m;
	srand(18311);
	
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			cin>>a[i][j]; 
			a[i][j]--;
		}
	}
	
	/*
	vi perm;
	for(int i=0;i<n*m;i++) perm.pb(i);
	random_shuffle(perm.begin(),perm.end());
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			a[i][j]=perm[i*m+j];
			cerr<<a[i][j]+1<<' ';
		}
		cerr<<'\n';
	}
	*/
	solve(0,0,n-1,m-1);
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			cout<<a[i][j]+1;
			if(j+1<m) cout<<' ';
		}
		cout<<'\n';
	}
	for(int j=0;j<m;j++)
	{
		vi vec(n);
		for(int i=0;i<n;i++)
		{
			vec[a[i][j]/m]=a[i][j];
		}
		for(int i=0;i<n;i++)
		{
			a[i][j]=vec[i];
		}
	}
	for(int i=0;i<n;i++)
	{
		for(int j=0;j<m;j++)
		{
			cout<<a[i][j]+1;
			if(j+1<m) cout<<' ';
		}
		cout<<'\n';
	}
	for(int i=0;i<n;i++)
	{
		vi vec;
		for(int j=0;j<m;j++)
		{
			vec.pb(a[i][j]);
		}
		sort(vec.begin(),vec.end());
		for(int j=0;j<m;j++)
		{
			assert(vec[j]==i*m+j);
		}
	}
}


Measured memory_bytes: 20792