#include<bits/stdc++.h>
using namespace std;
#define crap ios::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL)
 
typedef long long int ll;
typedef unsigned long long ull;

#define int ll

typedef std::vector<int> vi;
typedef std::vector<ll> vll;
typedef std::vector<vi > vvi;
typedef std::vector<vll > vvll;
typedef std::pair<int,int> ii;
typedef std::pair<int, ii > iii;
typedef std::pair< ll, ll > lp;
typedef std::vector<ii> vii;
typedef std::vector<vii > vvii;
 
#define pb push_back 
#define PB pop_back
#define pf push_front
#define PF pop_front
#define mp make_pair
#define ub(a,b) upper_bound(all(a),b)
#define lb(a,b) lower_bound(all(a),b)
#define bs(a,b) binary_search(all(a),b)
#define mem(a,b) memset(a,b,sizeof(a))
#define in(a,n) F(i,0,n-1)cin>>a[i]
#define in1(a,n) F(i,1,n)cin>>a[i]
#define out(a,n) F(i,0,n-1)cout<<a[i]<<" ";cout<<endl
#define ff first
#define ss second
#define F(i,a,b) for (ll i=a;i<=b;i++)
#define RF(i,a,b) for(ll i=a;i>=b;i--)
#define rep(i,n) F(i,0,n-1)
#define clr(a) (a).clear()
#define rz resize
#define sqr(a) ((a) * (a))
#define sz(a) int((a).size())
#define len(a) int((a).length())
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin() ,(a).rend()
#define endl '\n'
 
#define mod 1000000007
// #define mod 998244353

// ################################## Debugging statements  ##################################
string to_string(string s) {return '"' + s + '"';}
string to_string(const char* s) {return to_string((string) s);}
string to_string(bool b) {return (b ? "true" : "false");}
template <typename A, typename B>
string to_string(pair<A, B> p) {return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";}
template <typename A>
string to_string(A v) {bool first = true;  string res = "{";for (const auto &x : v) {if (!first) { res += ", "; }first = false; res += to_string(x);}res += "}";return res;}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {cerr << " " << to_string(H);debug_out(T...);}
#define TRACE // comment this out for submission
#ifdef TRACE
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
// ###########################################################################################
 
inline int add(int a, int b){a += b; if(a >= mod)a -= mod; return a;}
inline int sub(int a, int b){a -= b; if(a < 0)a += mod; return a;}
inline int mul(int a, int b){return (int)((long long) a * b %mod);}
inline int poww(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = mul(res, a); a = mul(a, a);b /= 2;} return res;}
inline int inv(int a){return poww(a, mod - 2);}
int gcd(int a, int b, int &x, int &y){if(a == 0){x = 0, y = 1; return b;} int x1, y1;  int d = gcd(b%a, a, x1, y1); x = y1 - (b/a) * x1; y = x1; return d;}
 
// #################################### matrix operations ####################################
inline vvi matmul(vvi A, vvi B) {int p = A.size(), q = A[0].size();int r = B.size(), s = B[0].size();assert(q == r);vvi C(p, vi(s, 0LL));
	rep(i, p){rep(j, s){rep(k, q){
				// C[i][j] += A[i][k] * B[k][j]; 
				C[i][j] = add(C[i][j], mul(A[i][k], B[k][j]));
	}}}return C;}
 
inline vvi matpow(vvi A, int n){int p = A.size(), q = A[0].size();assert(p == q);vvi res(p, vi(p, 0));rep(i, p)res[i][i] = 1;while (n){if (n&1)res = matmul(res, A);A = matmul(A, A);n >>= 1;}return res;}
 
// ###########################################################################################
 
// #################################### Combinatorics template ###############################
struct factorial{
	int N;int *fac;int *ifac;int MOD;
	factorial(int n, int m = 1000000007){N = n;MOD = m;fac = new int[1+N];ifac = new int[1+N];pre_calc();}
	int add(int a, int b){a += b; if(a >= MOD)a -= MOD; return a;}
	int subtract(int a, int b){a -= b; if(a < 0)a += MOD; return a;}
	int multiply(int a, int b){return (int)((long long) a * b %MOD);}
	int binpow(int a, int b){int res = 1; while(b > 0){ if(b & 1)res = multiply(res, a); a = multiply(a, a);b /= 2;} return res;}
	int inverse(int a){return binpow(a, MOD - 2);}
	void pre_calc(){fac[0] = ifac[0] = 1;for (int i = 1 ; i <= N ; i++){fac[i] = multiply(fac[i-1], i);ifac[i] = multiply(ifac[i-1], inverse(i));}}
	int ncr(int n , int r){return multiply(fac[n], multiply(ifac[r], ifac[n-r]));}
	int derangement(int n){
		if (n == 1) return 0;
		int ans = 0;
		for (int i = 2; i <= n ; i++){
			int sign = (i%2) ? -1 : 1;
			ans = add(ans, multiply(sign, fac[n]/fac[i]));
		}
		return ans;
	}
};

vi factors_n(int n){std::vector<int> fac;for (int i = 1; i * i <= n ; i++){if (n % i == 0){fac.push_back(i);if (i * i != n){fac.push_back(n/i);}}}return fac;}
// ###########################################################################################
 
// ##################################### Fenwick Tree template ###############################
struct fenwick_tree{
	int *bit;int n;
	fenwick_tree(){this->n = 100005;this->bit = new int[100005+1];}
	fenwick_tree(int n){this->n = n;this->bit = new int[n+1];}
	void add(int i, int v){for (; i<=this->n; i+= i&-i)this->bit[i] += v;}
	int get(int i){int s = 0;for (; i; i -= i&-i){s += this->bit[i];}return s;}
};
// ###########################################################################################
 
// ######################################## Policy-based DS ##################################
// #include<ext/pb_ds/assoc_container.hpp>
// using namespace __gnu_pbds;
 
// template<class key, class value = null_type, class cmp = std::less<key>>
// using ordered_tree = tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// order_of_key (val): returns the no. of values less than val
// find_by_order (k): returns the iterator to kth largest element.(0-based)
 
// ###########################################################################################

// ######################################## Bit manipulations ##################################
int no_of_ones(int n){return __builtin_popcount(n);}
int setmask(int mask, int i){return mask | (1 << i);}
int unsetmask(int mask, int i){return (mask & !(1 << i));}
// ###########################################################################################

// ###################################### Convex Hull Trick  ##################################
// struct Line {
//     mutable ll k, m, p;
//     bool operator<(const Line& o) const { return k < o.k; }
//     bool operator<(ll x) const { return p < x; }
// };
 
// struct LineContainer : multiset<Line, less<>> {
//     // (for doubles, use inf = 1/.0, div(a,b) = a/b)
//     const ll inf = LLONG_MAX;
//     ll div(ll a, ll b) { // floored division
//         return a / b - ((a ^ b) < 0 && a % b); }
//     bool isect(iterator x, iterator y) {
//         if (y == end()) { x->p = inf; return false; }
//         if (x->k == y->k) x->p = x->m > y->m ? inf : -inf;
//         else x->p = div(y->m - x->m, x->k - y->k);
//         return x->p >= y->p;
//     }
//     void add(ll k, ll m) { // y = k * x + m
//         auto z = insert({k, m, 0}), y = z++, x = y;
//         while (isect(y, z)) z = erase(z);
//         if (x != begin() && isect(--x, y)) isect(x, y = erase(y));
//         while ((y = x) != begin() && (--x)->p >= y->p)
//             isect(x, erase(y));
//     }
//     ll query(ll x) {
//         assert(!empty());
//         auto l = *lower_bound(x);
//         return l.k * x + l.m;
//     }
// };
// ###########################################################################################

int dx[] = {0, 0};
int dy[] = {1, -1};

// ################################### Template ends here ####################################

const int N = 305;
int h, w, k;
char a[N][N];
int ans[N][N];

signed main(){
	crap;
	cin >> h >> w >> k;
	int num = 1;
	int filled = 0;
	vi cols[w];
	rep(i, h){
		rep(j, w){
			cin >> a[i][j];
			if (a[i][j] == '#'){
				ans[i][j] = num++;
				cols[j].pb(i);
			}
		}
	}
	rep(j, w){
		if (sz(cols[j]) == 0)continue;
		if (sz(cols[j]) == 1){
			int col = ans[cols[j].front()][j];
			rep(i, h){
				ans[i][j] = col;
			}
		}
		else{
			int prev = 0;
			int col;
			for (int x : cols[j]){
				col = ans[x][j];
				for (int i = prev; i < x; i++){
					ans[i][j] = col;
				}
				prev = x + 1;
			}
			for (int i = prev; i < h; i++){
				ans[i][j] = col;
			}
		}
	}

	int flag = 0;

	rep(j, w){
		if (ans[0][j])continue;
		if (j == 0){
			flag = 1;
		}
		else{
			rep(i, h){
				ans[i][j] = ans[i][j-1];
			}
		}
	}

	if (flag){
		RF(j, w-1, 0){
			if (ans[0][j])continue;
			if (j == w-1){

			}
			else{
				rep(i, h){
					ans[i][j] = ans[i][j+1];
				}
			}
		}
	}

	flag = 0;

	rep(j, w){
		if (ans[0][j])continue;
		if (j == 0){
			flag = 1;
		}
		else{
			rep(i, h){
				ans[i][j] = ans[i][j-1];
			}
		}
	}

	if (flag){
		RF(j, w-1, 0){
			if (ans[0][j])continue;
			if (j == w-1){

			}
			else{
				rep(i, h){
					ans[i][j] = ans[i][j+1];
				}
			}
		}
	}


	rep(i, h){
		rep(j, w){
			cout << ans[i][j] << " ";
		}
		cout << endl;
	}
}

Measured memory_bytes: 2944