Problem: We have a grid with N rows and M columns of squares. Each integer from 1 to NM is written in this grid once. The number written in the square at the i-th row from the top and the j-th column from the left is A_{ij}.

You need to rearrange these numbers as follows:

1. First, for each of the N rows, rearrange the numbers written in it as you like.
2. Second, for each of the M columns, rearrange the numbers written in it as you like.
3. Finally, for each of the N rows, rearrange the numbers written in it as you like.



After rearranging the numbers, you want the number written in the square at the i-th row from the top and the j-th column from the left to be M\times (i-1)+j. Construct one such way to rearrange the numbers. The constraints guarantee that it is always possible to achieve the objective.

Constraints

* 1 \leq N,M \leq 100
* 1 \leq A_{ij} \leq NM
* A_{ij} are distinct.

Input

Input is given from Standard Input in the following format:


N M
A_{11} A_{12} ... A_{1M}
:
A_{N1} A_{N2} ... A_{NM}


Output

Print one way to rearrange the numbers in the following format:


B_{11} B_{12} ... B_{1M}
:
B_{N1} B_{N2} ... B_{NM}
C_{11} C_{12} ... C_{1M}
:
C_{N1} C_{N2} ... C_{NM}


Here B_{ij} is the number written in the square at the i-th row from the top and the j-th column from the left after Step 1, and C_{ij} is the number written in that square after Step 2.

Examples

Input

3 2
2 6
4 3
1 5


Output

2 6
4 3
5 1
2 1
4 3
5 6


Input

3 4
1 4 7 10
2 5 8 11
3 6 9 12


Output

1 4 7 10
5 8 11 2
9 12 3 6
1 4 3 2
5 8 7 6
9 12 11 10

Solution (in CPP):

Solution:
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
int a[105][105],b[105][105],G[205],to[20405],cap[20405],nxt[20405],sz=-1,d[205],cur[205],id[105][105],n,tmp[105];
bool used[105][105];
queue<int> Q;
inline void adde(int u,int v,int c){
	to[++sz]=v;cap[sz]=c;nxt[sz]=G[u];G[u]=sz;
	to[++sz]=u;cap[sz]=0;nxt[sz]=G[v];G[v]=sz;
}
inline bool bfs(){
	int i,u,v;
	memset(d,0x3f,sizeof(d));
	d[0]=0;Q.push(0);
	while(!Q.empty()){
		u=Q.front();Q.pop();
		for(i=G[u];i!=-1;i=nxt[i])if(cap[i]&&d[v=to[i]]==0x3f3f3f3f){
			d[v]=d[u]+1;
			Q.push(v);
		}
	}
	return d[n<<1|1]!=0x3f3f3f3f;
}
int dfs(int u,int a){
	if(u==(n<<1|1)||!a)return a;
	int v,flow=0,f;
	for(int &i=cur[u];i!=-1;i=nxt[i])if(d[v=to[i]]==d[u]+1&&(f=dfs(v,min(a,cap[i])))){
		flow+=f;
		cap[i]-=f;cap[i^1]+=f;
		if(!(a-=f))break;
	}
	return flow;
}
inline void dinic(){
	while(bfs()){
		memcpy(cur,G,sizeof(cur));
		dfs(0,0x3f3f3f3f);
	}
}
int main(){
	int m,i,j,k;
	scanf("%d%d",&n,&m);
	memset(G,-1,sizeof(G));
	for(i=1;i<=n;++i){adde(0,i,0);adde(i+n,n<<1|1,0);}
	for(i=1;i<=n;++i)
		for(j=1;j<=m;++j){
			scanf("%d",&a[i][j]);
			id[i][j]=sz+1;
			adde(i,(a[i][j]+m-1)/m+n,1);
		}
	for(i=1;i<=m;++i){
		for(j=0;j<(n<<2);j+=4){++cap[j];++cap[j+2];}
		dinic();
		for(j=1;j<=n;++j)
			for(k=1;k<=m;++k)if(!used[j][k]&&!cap[id[j][k]]){
				b[j][i]=a[j][k];
				used[j][k]=1;
				cap[id[j][k]^1]=0;
			}
	}
	for(i=1;i<=n;++i){
		for(j=1;j<=m;++j)printf("%d ",b[i][j]);
		putchar('\n');
	}
	for(j=1;j<=m;++j){
		for(i=1;i<=n;++i)tmp[i]=b[i][j];
		sort(tmp+1,tmp+n+1);
		for(i=1;i<=n;++i)b[i][j]=tmp[i];
	}
	for(i=1;i<=n;++i){
		for(j=1;j<=m;++j)printf("%d ",b[i][j]);
		putchar('\n');
	}
	return 0;
}