#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

// #define Debug
// #define LOCAL
// #define TestCases

const int N = 500, SZ = N * N;

int n, m;
int type[N + 5][N + 5];

namespace Splay
{
	struct Node
	{
		int ch[2], fa;
		int sz;
	} node[SZ + 5];
	int root, tot;

	#define ls(p) node[p].ch[0]
	#define rs(p) node[p].ch[1]
	#define fa(p) node[p].fa
	#define sz(p) node[p].sz

	int newnode()
	{
		int p = ++tot;
		sz(p) = 1;
		return p;
	}
	void pushup(int p)
	{
		sz(p) = sz(ls(p)) + 1 + sz(rs(p));
		return ;
	}
	int sontype(int p)
	{
		return rs(fa(p)) == p;
	}

	void rotate(int p)
	{
		int f = fa(p), type = sontype(p);
		int son = node[p].ch[!type];

		node[f].ch[type] = son;
		if (son)
			fa(son) = f;

		fa(p) = fa(f);
		if (fa(f))
			node[fa(f)].ch[sontype(f)] = p;

		node[p].ch[!type] = f;
		fa(f) = p;

		pushup(f);
		pushup(p);
		return ;
	}
	void splay(int p)
	{
		for (int f = fa(p); f = fa(p); rotate(p))
			if (fa(f))
				rotate(sontype(p) == sontype(f) ? f : p);
		root = p;
		return ;
	}

	int get_rank(int p)
	{
		splay(p);
		return sz(ls(p)) + 1;
	}
	bool is_max(int p)
	{
		splay(p);
		return !rs(p);
	}

	void add_left(int p, int lst)
	{
		if (!lst)
		{
			root = p;
			return ;
		}
		splay(lst);

		if (!ls(lst))
		{
			ls(lst) = p, fa(p) = lst;
			pushup(lst);
			splay(p);
			return ;
		}
		sz(lst)++;
		
		lst = ls(lst);
		while (rs(lst))
		{
			sz(lst)++;
			lst = rs(lst);
		}

		rs(lst) = p, fa(p) = lst;
		pushup(lst);
		splay(p);
		return ;
	}
	void add_right(int p, int lst)
	{
		if (!lst)
		{
			root = p;
			return ;
		}
		splay(lst);

		if (!rs(lst))
		{
			rs(lst) = p, fa(p) = lst;
			pushup(lst);
			splay(p);
			return ;
		}
		sz(lst)++;

		lst = rs(lst);
		while (ls(lst))
		{
			sz(lst)++;
			lst = ls(lst);
		}

		ls(lst) = p, fa(p) = lst;
		pushup(lst);
		splay(p);
		return ;
	}

	#ifdef Debug
	void print(int u)
	{

		if (ls(u) && fa(ls(u)) != u)
			cout << "left son err" << endl, exit(0);
		if (rs(u) && fa(rs(u)) != u)
			cout << "right son err" << endl, exit(0);

		if (ls(u))
			print(ls(u));
		printf("(%d, sz = %d, ls = %d, rs = %d)\n", u, sz(u), ls(u), rs(u));
		if (rs(u))
			print(rs(u));
		return ;
	}
	void print()
	{
		print(root);
		cout << endl;
		return ;
	}
	#endif
}

int id[N + 5][N + 5];

int cmp(double x, double y)
{
	if (x < y)
		return -1;
	return 1;
}
bool check(double p, double A, double B, double C, int type)
{
	if (type == 1)
	{
		return (cmp(p, A) == cmp(A, C) && cmp(A, C) == cmp(C, B)) || 
				(cmp(A, C) == cmp(C, B) && cmp(C, B) == cmp(B, p)) || 
				(cmp(C, B) == cmp(B, p) && cmp(B, p) == cmp(p, A)) || 
				(cmp(B, p) == cmp(p, A) && cmp(p, A) == cmp(A, C));
	}
	if (type == 2)
	{
		return (cmp(p, A) == cmp(A, B) && cmp(A, B) == cmp(B, C)) || 
				(cmp(A, B) == cmp(B, C) && cmp(B, C) == cmp(C, p)) || 
				(cmp(B, C) == cmp(C, p) && cmp(C, p) == cmp(p, A)) || 
				(cmp(C, p) == cmp(p, A) && cmp(p, A) == cmp(A, B));
	}
	return (cmp(p, B) == cmp(B, A) && cmp(B, A) == cmp(A, C)) || 
			(cmp(B, A) == cmp(A, C) && cmp(A, C) == cmp(C, p)) || 
			(cmp(A, C) == cmp(C, p) && cmp(C, p) == cmp(p, B)) || 
			(cmp(C, p) == cmp(p, B) && cmp(p, B) == cmp(B, A));
}

void solve()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i < n; i++)
		for (int j = 1; j < m; j++)
			scanf("%1d", &type[i][j]);

	for (int j = 1; j <= m; j++)
	{
		id[n][j] = Splay :: newnode();
		Splay :: add_right(id[n][j], id[n][j - 1]);

		#ifdef Debug
		// Splay :: print();
		#endif
	}
	for (int i = n - 1; i > 0; i--)
	{
		id[i][m] = Splay :: newnode();
		Splay :: add_right(id[i][m], id[i + 1][m]);
	}
	
	#ifdef Debug
	// Splay :: print();
	#endif

	#ifdef Debug
	#endif

	for (int i = n - 1; i > 0; i--)
	for (int j = m - 1; j > 0; j--)
	{
		/*
			(i, j)  A
			  C     B
		*/

		int A = Splay :: get_rank(id[i][j + 1]);

		#ifdef Debug
		cout << "calc A: " << id[i][j + 1] << endl;
		Splay :: print();
		#endif

		int B = Splay :: get_rank(id[i + 1][j + 1]);

		#ifdef Debug
		cout << "calc B: " << id[i + 1][j + 1] << endl;
		Splay :: print();
		#endif

		int C = Splay :: get_rank(id[i + 1][j]);



		int p = Splay :: newnode(), ty = type[i][j];
		id[i][j] = p;

		#ifdef Debug
		cout << "before " << i << " " << j << endl;
		Splay :: print();
		cout << "p = " << p << " A = " << A << " B = " << B << " C = " << C << endl;
		cout << id[i][j + 1] << " " << id[i + 1][j + 1] << " " << id[i + 1][j] << endl;
		cout << endl;
		#endif

		if (check(A - 0.5, A, B, C, ty))
		{
			Splay :: add_left(p, id[i][j + 1]);
			continue;
		}
		if (check(A + 0.5, A, B, C, ty))
		{
			Splay :: add_right(p, id[i][j + 1]);

			#ifdef Debug
			cout << "A + 0.5" << endl;
			Splay :: print();
			#endif
			continue;
		}

		if (check(B - 0.5, A, B, C, ty))
		{
			Splay :: add_left(p, id[i + 1][j + 1]);
			continue;
		}
		if (check(B + 0.5, A, B, C, ty))
		{
			Splay :: add_right(p, id[i + 1][j + 1]);
			continue;
		}

		if (check(C - 0.5, A, B, C, ty))
		{
			Splay :: add_left(p, id[i + 1][j]);
			continue;
		}
		if (check(C + 0.5, A, B, C, ty))
		{
			Splay :: add_right(p, id[i + 1][j]);
			continue;
		}

		#ifdef Debug
		cout << "!!!" << endl;
		exit(0);
		#endif
	}

	#ifdef Debug
	Splay :: print();

	cout << Splay :: tot << endl;
	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
			cout << id[i][j] << " ";
		cout << endl;
	}
	cout << endl;
	#endif

	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
			printf("%d ", Splay :: get_rank(id[i][j]));
		printf("\n");
	}
	return ;
}

int main()
{
	#ifdef LOCAL
	freopen("data.in", "r", stdin);
	freopen("mycode.out", "w", stdout);
	#endif
	
	int T = 1;
	
	#ifdef TestCases
	scanf("%d", &T);
	#endif
	
	while (T--)
		solve();
	return 0;
}