	    /*
	     * Author- Priyam Vora
	     * BTech 2nd Year DAIICT
	     */

	    import java.io.*;
	    import java.math.*;
	    import java.util.*;
	    import javax.print.attribute.SetOfIntegerSyntax;

	    public class Graph1 {
	    	private static InputStream stream;
	    	private static byte[] buf = new byte[1024];
	    	private static int curChar;
	    	private static int numChars;
	    	private static SpaceCharFilter filter;
	    	private static PrintWriter pw;
	    	private static long count = 0,mod=1000000007;
	    	private static TreeSet<Integer>ts[]=new TreeSet[200000];
	    	private static HashSet hs=new HashSet();

	    	public static void main(String args[]) throws Exception {
	    		InputReader(System.in);
	    		pw = new PrintWriter(System.out);
	    		//ans();
	    		soln();
	    		pw.close();
	    	}

	    	public static long gcd(long x, long y) {
	    		if (x == 0)
	    			return y;
	    		else
	    			return gcd( y % x,x);
	    	}

	    	private static int BinarySearch(int a[], int low, int high, int target) {
	    		if (low > high)
	    			return -1;
	    		int mid = low + (high - low) / 2;
	    		if (a[mid] == target)
	    			return mid;
	    		if (a[mid] > target)
	    			high = mid - 1;
	    		if (a[mid] < target)
	    			low = mid + 1;
	    		return BinarySearch(a, low, high, target);
	    	}

	    	public static String reverseString(String s) {
	    		StringBuilder sb = new StringBuilder(s);
	    		sb.reverse();
	    		return (sb.toString());
	    	}

	    	public static long pow(long n, long p) {
	    		if(p==0)
	    			return 1;
	    		if(p==1)
	    			return n%mod;
	    		if(p%2==0){
	    			long temp=pow(n, p/2);
	    		return (temp*temp)%mod;
	    		}else{
	    			 	long temp=pow(n,p/2);
	    			 	temp=(temp*temp)%mod;
	    			 	return(temp*n)%mod;

	    		}
	    	}

	    	public static int[] radixSort(int[] f) {
	    		int[] to = new int[f.length];
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] & 0xffff)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] & 0xffff]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] >>> 16)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] >>> 16]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		return f;
	    	}

	    	public static int nextPowerOf2(final int a) {
	    		int b = 1;
	    		while (b < a) {
	    			b = b << 1;
	    		}
	    		return b;
	    	}

	    	public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
	    		int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
	    		int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;

	    		if ((s < 0) != (t < 0))
	    			return false;

	    		int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
	    		if (A < 0.0) {
	    			s = -s;
	    			t = -t;
	    			A = -A;
	    		}
	    		return s > 0 && t > 0 && (s + t) <= A;
	    	}

	    	public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
	    		return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
	    	}

	    	public static boolean isPrime(int n) {
	    		// Corner cases
	    		if (n <= 1)
	    			return false;
	    		if (n <= 3)
	    			return true;

	    		// This is checked so that we can skip
	    		// middle five numbers in below loop
	    		if (n % 2 == 0 || n % 3 == 0)
	    			return false;

	    		for (int i = 5; i * i <= n; i = i + 6)
	    			if (n % i == 0 || n % (i + 2) == 0)
	    				return false;

	    		return true;
	    	}

	    	//merge Sort

	    	static long sort(int a[])
	    	{  int n=a.length;
	    		int b[]=new int[n];
	    		return mergeSort(a,b,0,n-1);}
	    	static long mergeSort(int a[],int b[],long left,long right)
	    	{ long c=0;if(left<right)
	    	 {   long mid=left+(right-left)/2;
	    		 c= mergeSort(a,b,left,mid);
	    		 c+=mergeSort(a,b,mid+1,right);
	    		 c+=merge(a,b,left,mid+1,right); }
	    		return c;	 }
	    	static long merge(int a[],int  b[],long left,long mid,long right)
	    	{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
	    	while(i<=(int)mid-1&&j<=(int)right)
	    	{ if(a[i]>a[j]) {b[k++]=a[i++]; }
	    	else	{ b[k++]=a[j++];c+=mid-i;}}
	    	while (i <= (int)mid - 1)   b[k++] = a[i++];
	    	while (j <= (int)right) b[k++] = a[j++];
	    	for (i=(int)left; i <= (int)right; i++)
	    		a[i] = b[i];  return c;  }
	    	public static boolean isSubSequence(String large, String small, int largeLen, int smallLen) {
	    		//base cases
	    		if (largeLen == 0)
	    			return false;
	    		if (smallLen == 0)
	    			return true;
	    		// If last characters of two strings are matching
	    		if (large.charAt(largeLen - 1) == small.charAt(smallLen - 1))
	    			isSubSequence(large, small, largeLen - 1, smallLen - 1);
	    		// If last characters are not matching
	    		return isSubSequence(large, small, largeLen - 1, smallLen);
	    	}

	    	// To Get Input
	    	// Some Buffer Methods

	    	public static void InputReader(InputStream stream1) {
	    		stream = stream1;
	    	}

	    	private static boolean isWhitespace(int c) {
	    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    	}

	    	private static boolean isEndOfLine(int c) {
	    		return c == '\n' || c == '\r' || c == -1;
	    	}

	    	private static int read() {
	    		if (numChars == -1)
	    			throw new InputMismatchException();
	    		if (curChar >= numChars) {
	    			curChar = 0;
	    			try {
	    				numChars = stream.read(buf);
	    			} catch (IOException e) {
	    				throw new InputMismatchException();
	    			}
	    			if (numChars <= 0)
	    				return -1;
	    		}
	    		return buf[curChar++];
	    	}

	    	private static int nextInt() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		int sgn = 1;
	    		if (c == '-') {
	    			sgn = -1;
	    			c = read();
	    		}
	    		int res = 0;
	    		do {
	    			if (c < '0' || c > '9')
	    				throw new InputMismatchException();
	    			res *= 10;
	    			res += c - '0';
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res * sgn;
	    	}

	    	private static long nextLong() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		int sgn = 1;
	    		if (c == '-') {
	    			sgn = -1;
	    			c = read();
	    		}
	    		long res = 0;
	    		do {
	    			if (c < '0' || c > '9')
	    				throw new InputMismatchException();
	    			res *= 10;
	    			res += c - '0';
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res * sgn;
	    	}

	    	private static String nextToken() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res.toString();
	    	}

	    	private static String nextLine() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isEndOfLine(c));
	    		return res.toString();
	    	}

	    	private static int[] nextIntArray(int n) {
	    		int[] arr = new int[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextInt();
	    		}
	    		return arr;
	    	}

	    	private static int[][] next2dArray(int n, int m) {
	    		int[][] arr = new int[n][m];
	    		for (int i = 0; i < n; i++) {
	    			for (int j = 0; j < m; j++) {
	    				arr[i][j] = nextInt();
	    			}
	    		}
	    		return arr;
	    	}
	    	private static char[][] nextCharArray(int n,int m){
	    		char [][]c=new char[n][m];
	    		for(int i=0;i<n;i++){
	    			String s=nextLine();
	    			c[i]=s.toCharArray();
	    		}
	    		return c;
	    	}

	    	private static long[] nextLongArray(int n) {
	    		long[] arr = new long[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextLong();
	    		}
	    		return arr;
	    	}

	    	private static void pArray(int[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(long[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(boolean[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static boolean isSpaceChar(int c) {
	    		if (filter != null)
	    			return filter.isSpaceChar(c);
	    		return isWhitespace(c);
	    	}

	    	private interface SpaceCharFilter {
	    		public boolean isSpaceChar(int ch);
	    	}

	    	//----------------------------------------My Code------------------------------------------------//

	    	private static void soln() {

	    		int n=nextInt();
	    		int m=nextInt();
	    		char c[][]=nextCharArray(n, m);
	    		Graph g=new Graph(n);
	    		for(int i=0;i<n;i++){
	    			for(int j=0;j<m;j++){
	    				if(c[i][j]=='*'){
	    					pw.print(g.BFS(i, j, c));
	    					//break;
	    				}else{
	    					pw.print(".");
	    				}
	    			}
	    			pw.println();
	    		}

	    	}
	    		//-----------------------------------------The End--------------------------------------------------------------------------//

	    }

		class Pair implements Comparable<Pair>{

			int idx,val;
			Pair(int idx,int val){
				this.idx=idx;
				this.val=val;
			}
			@Override
			public int compareTo(Pair o) {
				// TODO Auto-generated method stub
			//	Sort in increasing order

				if(o.idx<idx){
					return 1;
				}
				if(o.idx==idx && o.val<val){
					return 1;
				}else{
					return -1;
				}

			}

		}
	        class Graph{
	        	private int V,level[][],count=-1,lev_dfs[],degree=0;
	        	private Stack <Integer>st=new Stack();
	        	private LinkedList<Integer > adj[];
	        	private boolean[][] Visite;
	        	private boolean [] Visited;
	    Graph(int V){
	    V++;
	    this.V=(V);
	    adj=new LinkedList[V];
	    Visite=new boolean[1000][1000];
	    Visited=new boolean[V];
	    level=new int[100][100];
	   lev_dfs=new int[V];
	   for(int i=0;i<V;i++)
		   adj[i]=new LinkedList<Integer>();
	    }

	    void addEdge(int v,int w){

	    	if(adj[v]==null){
	    		adj[v]=new LinkedList();
	    	}
	    	adj[v].add(w);

	    }

	    public int getEd(){
	    	return degree/2;
	    }

	    private static boolean check(int x,int y,char c[][]){

			if((x>=0 && y>=0) && (x<c.length && y<c[0].length) && c[x][y]=='.'){

				return true;
			}
			return false;
		}
	    public long BFS(int x,int y,char[][] c)
	    {
	    	 LinkedList<Pair> queue = new LinkedList<Pair>();
	        //Visited[s]=true;
	        queue.add(new Pair(x,y));
	       long count=0;
	   level[x][y]=-1;
	  Visite=new boolean[1000][1000];
	        while (!queue.isEmpty())
	        {
	            Pair temp = queue.poll();
	            x=temp.idx;
	            y=temp.val;
	            count++;

	       //System.out.println(x+" "+y+" ---"+count);

	         // System.out.println(x+" "+y);
	           // V--;
	           if(check(x+1, y, c) && !Visite[x+1][y]){
	        	queue.add(new Pair(x+1,y));
	        	Visite[x+1][y]=true;
	           }
	           if(check(x-1, y, c) && !Visite[x-1][y]){
		        	queue.add(new Pair(x-1,y));
		        	Visite[x-1][y]=true;
		           }
	           if(check(x, y+1, c) && !Visite[x][y+1]){
		        	queue.add(new Pair(x,y+1));
		        	Visite[x][y+1]=true;
		           }
	           if(check(x, y-1, c) && !Visite[x][y-1]){
		        	queue.add(new Pair(x,y-1));
		        	Visite[x][y-1]=true;
		           }
	        }
	        count%=10;

	        return count;
	    }

	     public long dfs(int startVertex){

	     if(!Visited[startVertex])  {

	    		  return dfsUtil(startVertex,Visited);

	    }

	    return -1;
	    	 }
	    private long dfsUtil(int startVertex, boolean[] Visited) {//0-Blue 1-Pink
	      long c=1;
	      degree=0;
	    	Visited[startVertex]=true;
	    	lev_dfs[startVertex]=0;
	      st.push(startVertex);
	    while(!st.isEmpty()){
	    	int top=st.pop();

	    	Iterator<Integer> i=adj[top].listIterator();
	     degree+=adj[top].size();
	    while(i.hasNext()){
	    //	System.out.println(top);
	    	int n=i.next();
	    		 if( !Visited[n]){
	    				Visited[n]=true;
	    					st.push(n);
	    					c++;

	    		 }
	    			 }

	    	}

	    return c;
	    	}

	    }

	    class Dsu{
	    	private int rank[], parent[] ,n;

	    	Dsu(int size){
	    		this.n=size+1;
	    		rank=new int[n];
	    		parent=new int[n];
	    	makeSet();
	    	}

	    	void makeSet(){
	    		for(int i=0;i<n;i++){
	    			parent[i]=i;
	    		}
	    	}

	    	int find(int x){
	    		if(parent[x]!=x){

	    			parent[x]=find(parent[x]);
	    		}
	    		return parent[x];
	    	}

	    	void union(int x,int y){
	    		int xRoot=find(x);
	    		int yRoot=find(y);

	    		if(xRoot==yRoot)
	    			return;
	    		if(rank[xRoot]<rank[yRoot]){
	    		parent[xRoot]=yRoot;
	    		}else if(rank[yRoot]<rank[xRoot]){
	    			parent[yRoot]=xRoot;
	    		}else{
	    			parent[yRoot]=xRoot;
	    			rank[xRoot]++;
	    		}

	    	}

	    }
	    class Heap{

	    	public static void build_max_heap(long []a,int size){

	    		for(int i=size/2;i>0;i--){
	    			max_heapify(a, i,size);
	    		}

	    			}
	    	private static void max_heapify(long[] a,int i,int size){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<size && a[left_child]>a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<size && a[right_child]>a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			long temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			max_heapify(a, largest,size);
	    		}
	    	}
	    	private static void min_heapify(int[] a,int i){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<a.length && a[left_child]<a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<a.length && a[right_child]<a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			int temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			min_heapify(a, largest);
	    		}
	    	}
	    	public static void extract_max(int size,long a[]){
	    		if(a.length>1){
	    			long max=a[1];
	    			a[1]=a[a.length-1];
	    			size--;
	    			max_heapify(a, 1,a.length-1);
	    		}
	    	}
	    }

	    class MyComp implements Comparator<Long>{

			@Override
			public int compare(Long o1, Long o2) {
				if(o1<o2){
					return 1;
				}else if(o1>o2){
					return -1;
				}
				return 0;

			}
	    }


 /*
	     * Author- Priyam Vora
	     * BTech 2nd Year DAIICT
	     */

	    import java.io.*;
	    import java.math.*;
	    import java.util.*;
	    import javax.print.attribute.SetOfIntegerSyntax;

	    public class Main{
	    	private static InputStream stream;
	    	private static byte[] buf = new byte[1024];
	    	private static int curChar;
	    	private static int numChars;
	    	private static SpaceCharFilter filter;
	    	private static PrintWriter pw;
	    	private static long count = 0,mod=1000000007;
	    	private static TreeSet<Integer>ts[]=new TreeSet[200000];
	    	private static HashSet hs=new HashSet();

	    	public static void main(String args[]) throws Exception {
	    		InputReader(System.in);
	    		pw = new PrintWriter(System.out);
	    		//ans();
	    		soln();
	    		pw.close();
	    	}

	    	public static long gcd(long x, long y) {
	    		if (x == 0)
	    			return y;
	    		else
	    			return gcd( y % x,x);
	    	}

	    	private static int BinarySearch(int a[], int low, int high, int target) {
	    		if (low > high)
	    			return -1;
	    		int mid = low + (high - low) / 2;
	    		if (a[mid] == target)
	    			return mid;
	    		if (a[mid] > target)
	    			high = mid - 1;
	    		if (a[mid] < target)
	    			low = mid + 1;
	    		return BinarySearch(a, low, high, target);
	    	}

	    	public static String reverseString(String s) {
	    		StringBuilder sb = new StringBuilder(s);
	    		sb.reverse();
	    		return (sb.toString());
	    	}

	    	public static long pow(long n, long p) {
	    		if(p==0)
	    			return 1;
	    		if(p==1)
	    			return n%mod;
	    		if(p%2==0){
	    			long temp=pow(n, p/2);
	    		return (temp*temp)%mod;
	    		}else{
	    			 	long temp=pow(n,p/2);
	    			 	temp=(temp*temp)%mod;
	    			 	return(temp*n)%mod;

	    		}
	    	}

	    	public static int[] radixSort(int[] f) {
	    		int[] to = new int[f.length];
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] & 0xffff)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] & 0xffff]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		{
	    			int[] b = new int[65537];
	    			for (int i = 0; i < f.length; i++)
	    				b[1 + (f[i] >>> 16)]++;
	    			for (int i = 1; i <= 65536; i++)
	    				b[i] += b[i - 1];
	    			for (int i = 0; i < f.length; i++)
	    				to[b[f[i] >>> 16]++] = f[i];
	    			int[] d = f;
	    			f = to;
	    			to = d;
	    		}
	    		return f;
	    	}

	    	public static int nextPowerOf2(final int a) {
	    		int b = 1;
	    		while (b < a) {
	    			b = b << 1;
	    		}
	    		return b;
	    	}

	    	public static boolean PointInTriangle(int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8) {
	    		int s = p2 * p5 - p1 * p6 + (p6 - p2) * p7 + (p1 - p5) * p8;
	    		int t = p1 * p4 - p2 * p3 + (p2 - p4) * p7 + (p3 - p1) * p8;

	    		if ((s < 0) != (t < 0))
	    			return false;

	    		int A = -p4 * p5 + p2 * (p5 - p3) + p1 * (p4 - p6) + p3 * p6;
	    		if (A < 0.0) {
	    			s = -s;
	    			t = -t;
	    			A = -A;
	    		}
	    		return s > 0 && t > 0 && (s + t) <= A;
	    	}

	    	public static float area(int x1, int y1, int x2, int y2, int x3, int y3) {
	    		return (float) Math.abs((x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0);
	    	}

	    	public static boolean isPrime(int n) {
	    		// Corner cases
	    		if (n <= 1)
	    			return false;
	    		if (n <= 3)
	    			return true;

	    		// This is checked so that we can skip
	    		// middle five numbers in below loop
	    		if (n % 2 == 0 || n % 3 == 0)
	    			return false;

	    		for (int i = 5; i * i <= n; i = i + 6)
	    			if (n % i == 0 || n % (i + 2) == 0)
	    				return false;

	    		return true;
	    	}

	    	//merge Sort

	    	static long sort(int a[])
	    	{  int n=a.length;
	    		int b[]=new int[n];
	    		return mergeSort(a,b,0,n-1);}
	    	static long mergeSort(int a[],int b[],long left,long right)
	    	{ long c=0;if(left<right)
	    	 {   long mid=left+(right-left)/2;
	    		 c= mergeSort(a,b,left,mid);
	    		 c+=mergeSort(a,b,mid+1,right);
	    		 c+=merge(a,b,left,mid+1,right); }
	    		return c;	 }
	    	static long merge(int a[],int  b[],long left,long mid,long right)
	    	{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
	    	while(i<=(int)mid-1&&j<=(int)right)
	    	{ if(a[i]>a[j]) {b[k++]=a[i++]; }
	    	else	{ b[k++]=a[j++];c+=mid-i;}}
	    	while (i <= (int)mid - 1)   b[k++] = a[i++];
	    	while (j <= (int)right) b[k++] = a[j++];
	    	for (i=(int)left; i <= (int)right; i++)
	    		a[i] = b[i];  return c;  }
	    	public static boolean isSubSequence(String large, String small, int largeLen, int smallLen) {
	    		//base cases
	    		if (largeLen == 0)
	    			return false;
	    		if (smallLen == 0)
	    			return true;
	    		// If last characters of two strings are matching
	    		if (large.charAt(largeLen - 1) == small.charAt(smallLen - 1))
	    			isSubSequence(large, small, largeLen - 1, smallLen - 1);
	    		// If last characters are not matching
	    		return isSubSequence(large, small, largeLen - 1, smallLen);
	    	}

	    	// To Get Input
	    	// Some Buffer Methods

	    	public static void InputReader(InputStream stream1) {
	    		stream = stream1;
	    	}

	    	private static boolean isWhitespace(int c) {
	    		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	    	}

	    	private static boolean isEndOfLine(int c) {
	    		return c == '\n' || c == '\r' || c == -1;
	    	}

	    	private static int read() {
	    		if (numChars == -1)
	    			throw new InputMismatchException();
	    		if (curChar >= numChars) {
	    			curChar = 0;
	    			try {
	    				numChars = stream.read(buf);
	    			} catch (IOException e) {
	    				throw new InputMismatchException();
	    			}
	    			if (numChars <= 0)
	    				return -1;
	    		}
	    		return buf[curChar++];
	    	}

	    	private static int nextInt() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		int sgn = 1;
	    		if (c == '-') {
	    			sgn = -1;
	    			c = read();
	    		}
	    		int res = 0;
	    		do {
	    			if (c < '0' || c > '9')
	    				throw new InputMismatchException();
	    			res *= 10;
	    			res += c - '0';
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res * sgn;
	    	}

	    	private static long nextLong() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		int sgn = 1;
	    		if (c == '-') {
	    			sgn = -1;
	    			c = read();
	    		}
	    		long res = 0;
	    		do {
	    			if (c < '0' || c > '9')
	    				throw new InputMismatchException();
	    			res *= 10;
	    			res += c - '0';
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res * sgn;
	    	}

	    	private static String nextToken() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isSpaceChar(c));
	    		return res.toString();
	    	}

	    	private static String nextLine() {
	    		int c = read();
	    		while (isSpaceChar(c))
	    			c = read();
	    		StringBuilder res = new StringBuilder();
	    		do {
	    			res.appendCodePoint(c);
	    			c = read();
	    		} while (!isEndOfLine(c));
	    		return res.toString();
	    	}

	    	private static int[] nextIntArray(int n) {
	    		int[] arr = new int[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextInt();
	    		}
	    		return arr;
	    	}

	    	private static int[][] next2dArray(int n, int m) {
	    		int[][] arr = new int[n][m];
	    		for (int i = 0; i < n; i++) {
	    			for (int j = 0; j < m; j++) {
	    				arr[i][j] = nextInt();
	    			}
	    		}
	    		return arr;
	    	}
	    	private static char[][] nextCharArray(int n,int m){
	    		char [][]c=new char[n][m];
	    		for(int i=0;i<n;i++){
	    			String s=nextLine();
	    			c[i]=s.toCharArray();
	    		}
	    		return c;
	    	}

	    	private static long[] nextLongArray(int n) {
	    		long[] arr = new long[n];
	    		for (int i = 0; i < n; i++) {
	    			arr[i] = nextLong();
	    		}
	    		return arr;
	    	}

	    	private static void pArray(int[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(long[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static void pArray(boolean[] arr) {
	    		for (int i = 0; i < arr.length; i++) {
	    			pw.print(arr[i] + " ");
	    		}
	    		pw.println();
	    		return;
	    	}

	    	private static boolean isSpaceChar(int c) {
	    		if (filter != null)
	    			return filter.isSpaceChar(c);
	    		return isWhitespace(c);
	    	}

	    	private interface SpaceCharFilter {
	    		public boolean isSpaceChar(int ch);
	    	}

	    	//----------------------------------------My Code------------------------------------------------//

	    	private static void soln() {

	    		int n=nextInt();
	    		int m=nextInt();
	    		char c[][]=nextCharArray(n, m);
	    		Graph g=new Graph(n);
	    		StringBuilder sb=new StringBuilder();
	    		for(int i=0;i<n;i++){
	    			for(int j=0;j<m;j++){
	    				if(c[i][j]=='*'){
	    					sb.append(g.BFS(i, j, c));
	    					//break;
	    				}else{
	    					sb.append(".");
	    				}
	    			}
sb.append("\n");
	    		}
	    		pw.println(sb);

	    	}
	    		//-----------------------------------------The End--------------------------------------------------------------------------//

	    }

		class Pair implements Comparable<Pair>{

			int idx,val;
			Pair(int idx,int val){
				this.idx=idx;
				this.val=val;
			}
			@Override
			public int compareTo(Pair o) {
				// TODO Auto-generated method stub
			//	Sort in increasing order

				if(o.idx<idx){
					return 1;
				}
				if(o.idx==idx && o.val<val){
					return 1;
				}else{
					return -1;
				}

			}

		}
	        class Graph{
	        	private int V,level[][],count=-1,lev_dfs[],degree=0;
	        	private Stack <Integer>st=new Stack();
	        	private LinkedList<Integer > adj[];
	        	private boolean[][] Visite;
	        	private boolean [] Visited;
	    Graph(int V){
	    V++;
	    this.V=(V);
	    adj=new LinkedList[V];
	    Visite=new boolean[1000][1000];
	    Visited=new boolean[V];
	    level=new int[100][100];
	   lev_dfs=new int[V];
	   for(int i=0;i<V;i++)
		   adj[i]=new LinkedList<Integer>();
	    }

	    void addEdge(int v,int w){

	    	if(adj[v]==null){
	    		adj[v]=new LinkedList();
	    	}
	    	adj[v].add(w);

	    }

	    public int getEd(){
	    	return degree/2;
	    }

	    private static boolean check(int x,int y,char c[][]){

			if((x>=0 && y>=0) && (x<c.length && y<c[0].length) && c[x][y]=='.'){

				return true;
			}
			return false;
		}
	    public long BFS(int x,int y,char[][] c)
	    {
	    	 LinkedList<Pair> queue = new LinkedList<Pair>();
	        //Visited[s]=true;
	        queue.add(new Pair(x,y));
	       long count=0;
	   level[x][y]=-1;
	  Visite=new boolean[1000][1000];
	        while (!queue.isEmpty())
	        {
	            Pair temp = queue.poll();
	            x=temp.idx;
	            y=temp.val;
	            count++;

	       //System.out.println(x+" "+y+" ---"+count);

	         // System.out.println(x+" "+y);
	           // V--;
	           if(check(x+1, y, c) && !Visite[x+1][y]){
	        	queue.add(new Pair(x+1,y));
	        	Visite[x+1][y]=true;
	           }
	           if(check(x-1, y, c) && !Visite[x-1][y]){
		        	queue.add(new Pair(x-1,y));
		        	Visite[x-1][y]=true;
		           }
	           if(check(x, y+1, c) && !Visite[x][y+1]){
		        	queue.add(new Pair(x,y+1));
		        	Visite[x][y+1]=true;
		           }
	           if(check(x, y-1, c) && !Visite[x][y-1]){
		        	queue.add(new Pair(x,y-1));
		        	Visite[x][y-1]=true;
		           }
	        }
	        count%=10;

	        return count;
	    }

	     public long dfs(int startVertex){

	     if(!Visited[startVertex])  {

	    		  return dfsUtil(startVertex,Visited);

	    }

	    return -1;
	    	 }
	    private long dfsUtil(int startVertex, boolean[] Visited) {//0-Blue 1-Pink
	      long c=1;
	      degree=0;
	    	Visited[startVertex]=true;
	    	lev_dfs[startVertex]=0;
	      st.push(startVertex);
	    while(!st.isEmpty()){
	    	int top=st.pop();

	    	Iterator<Integer> i=adj[top].listIterator();
	     degree+=adj[top].size();
	    while(i.hasNext()){
	    //	System.out.println(top);
	    	int n=i.next();
	    		 if( !Visited[n]){
	    				Visited[n]=true;
	    					st.push(n);
	    					c++;

	    		 }
	    			 }

	    	}

	    return c;
	    	}

	    }

	    class Dsu{
	    	private int rank[], parent[] ,n;

	    	Dsu(int size){
	    		this.n=size+1;
	    		rank=new int[n];
	    		parent=new int[n];
	    	makeSet();
	    	}

	    	void makeSet(){
	    		for(int i=0;i<n;i++){
	    			parent[i]=i;
	    		}
	    	}

	    	int find(int x){
	    		if(parent[x]!=x){

	    			parent[x]=find(parent[x]);
	    		}
	    		return parent[x];
	    	}

	    	void union(int x,int y){
	    		int xRoot=find(x);
	    		int yRoot=find(y);

	    		if(xRoot==yRoot)
	    			return;
	    		if(rank[xRoot]<rank[yRoot]){
	    		parent[xRoot]=yRoot;
	    		}else if(rank[yRoot]<rank[xRoot]){
	    			parent[yRoot]=xRoot;
	    		}else{
	    			parent[yRoot]=xRoot;
	    			rank[xRoot]++;
	    		}

	    	}

	    }
	    class Heap{

	    	public static void build_max_heap(long []a,int size){

	    		for(int i=size/2;i>0;i--){
	    			max_heapify(a, i,size);
	    		}

	    			}
	    	private static void max_heapify(long[] a,int i,int size){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<size && a[left_child]>a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<size && a[right_child]>a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			long temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			max_heapify(a, largest,size);
	    		}
	    	}
	    	private static void min_heapify(int[] a,int i){
	    		int left_child=2*i;
	    		int right_child=(2*i+1);
	    		int largest=0;

	    		if(left_child<a.length && a[left_child]<a[i]){
	    			largest=left_child;
	    		}else{
	    			largest=i;
	    		}

	    		if(right_child<a.length && a[right_child]<a[largest]){
	    			largest=right_child;
	    		}
	    		if(largest!=i){
	    			int temp=a[largest];
	    			a[largest]=a[i];
	    			a[i]=temp;
	    			min_heapify(a, largest);
	    		}
	    	}
	    	public static void extract_max(int size,long a[]){
	    		if(a.length>1){
	    			long max=a[1];
	    			a[1]=a[a.length-1];
	    			size--;
	    			max_heapify(a, 1,a.length-1);
	    		}
	    	}
	    }

	    class MyComp implements Comparator<Long>{

			@Override
			public int compare(Long o1, Long o2) {
				if(o1<o2){
					return 1;
				}else if(o1>o2){
					return -1;
				}
				return 0;

			}


import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(in, out);
        out.close();
    }

    public static class TaskC {
        private int di[] = {-1, 0, 1, 0};
        private int dj[] = {0, 1, 0, -1};

        public void solve(InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            char ar[][] = new char[n][m];
            for (int i = 0; i < n; i++) {
                String s = in.next();
                for (int j = 0; j < m; j++)
                    ar[i][j] = s.charAt(j);
            }
            int ID[][] = new int[n][m];
            Hashtable<Integer, Integer> hashTable = new Hashtable<>();
            int lastID = 0;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (ar[i][j] == '.') {
                        bfs(ar, i, j, ID, lastID, hashTable);
                        lastID++;
                    }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++)
                    if (ar[i][j] == '.')
                        out.print('.');
                    else {
                        HashSet<Integer> setID = new HashSet<>();
                        int ans = 0;
                        for (int dir = 0; dir < 4; dir++) {
                            int newI = i + di[dir];
                            int newJ = j + dj[dir];
                            if (in(newI, newJ, n, m) && ar[newI][newJ] == '.') {
                                int curID = ID[newI][newJ];
                                if (!setID.contains(curID)) {
                                    ans += hashTable.get(curID);
                                    setID.add(curID);
                                }
                            }
                        }
                        out.print((ans + 1) % 10);
                    }
                out.println("");
            }
        }

        private void bfs(char ar[][], int startI, int startJ, int ID[][], int lastID, Hashtable<Integer, Integer> table) {
            ArrayDeque<Point> deque = new ArrayDeque<>();
            deque.addLast(new Point(startI, startJ));
            int n = ar.length;
            int m = ar[0].length;
            int amount = 1;
            while (!deque.isEmpty()) {
                Point curPoint = deque.pollFirst();
                int i = curPoint.i;
                int j = curPoint.j;
                ID[i][j] = lastID + 1;
                ar[i][j] = '#';
                for (int dir = 0; dir < 4; dir++) {
                    int newI = i + di[dir];
                    int newJ = j + dj[dir];
                    if (in(newI, newJ, n, m) && ar[newI][newJ] == '.') {
                        ar[newI][newJ] = '#';
                        amount++;
                        deque.addLast(new Point(newI, newJ));
                    }
                }
            }
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (ar[i][j] == '#')
                        ar[i][j] = '.';
            table.put(lastID + 1, amount);
        }

        private boolean in(int i, int j, int n, int m) {
            return i >= 0 && i < n && j >= 0 && j < m;
        }

        private static class Point {
            private int i, j;

            public Point(int i, int j) {
                this.i = i;
                this.j = j;
            }
        }
    }

    public static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}


import java.io.*;
import java.util.*;

public class Main {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(in, out);
        out.close();
    }

    public static class TaskC {
        private int di[] = {-1, 0, 1, 0};
        private int dj[] = {0, 1, 0, -1};

        public void solve(InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            char ar[][] = new char[n][m];
            char rem[][] = new char[n][m];
            for (int i = 0; i < n; i++) {
                String s = in.next();
                for (int j = 0; j < m; j++)
                    rem[i][j] = ar[i][j] = s.charAt(j);
            }
            int ID[][] = new int[n][m];
            Hashtable<Integer, Integer> hashTable = new Hashtable<>();
            int lastID = 0;
            for (int i = 0; i < n; i++)
                for (int j = 0; j < m; j++)
                    if (ar[i][j] == '.') {
                        bfs(ar, i, j, ID, lastID, hashTable);
                        ar[i][j] = '.';
                        lastID++;
                    }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++)
                    if (rem[i][j] == '.')
                        out.print('.');
                    else {
                        HashSet<Integer> setID = new HashSet<>();
                        int ans = 0;
                        for (int dir = 0; dir < 4; dir++) {
                            int newI = i + di[dir];
                            int newJ = j + dj[dir];
                            if (in(newI, newJ, n, m) && (ar[newI][newJ] == '.' || ar[newI][newJ] == '#')) {
                                int curID = ID[newI][newJ];
                                if (!setID.contains(curID)) {
                                    ans += hashTable.get(curID);
                                    setID.add(curID);
                                }
                            }
                        }
                        out.print((ans + 1) % 10);
                    }
                out.println("");
            }
        }

        private void bfs(char ar[][], int startI, int startJ, int ID[][], int lastID, Hashtable<Integer, Integer> table) {
            ArrayDeque<Point> deque = new ArrayDeque<>();
            deque.addLast(new Point(startI, startJ));
            int n = ar.length;
            int m = ar[0].length;
            int amount = 1;
            while (!deque.isEmpty()) {
                Point curPoint = deque.pollFirst();
                int i = curPoint.i;
                int j = curPoint.j;
                ID[i][j] = lastID + 1;
                ar[i][j] = '#';
                for (int dir = 0; dir < 4; dir++) {
                    int newI = i + di[dir];
                    int newJ = j + dj[dir];
                    if (in(newI, newJ, n, m) && ar[newI][newJ] == '.') {
                        ar[newI][newJ] = '#';
                        amount++;
                        deque.addLast(new Point(newI, newJ));
                    }
                }
            }
            table.put(lastID + 1, amount);
        }

        private boolean in(int i, int j, int n, int m) {
            return i >= 0 && i < n && j >= 0 && j < m;
        }

        private static class Point {
            private int i, j;

            public Point(int i, int j) {
                this.i = i;
                this.j = j;
            }
        }
    }

    public static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}


import javafx.util.Pair;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        int[][] l = new int[1002][1002];
        int n, m;
        HashSet<Pair<Integer,Integer>> set;
        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            n = in.nextInt();
            m = in.nextInt();
            String[] tmp = new String[1002];
            for (int i = 0; i < n; i++) {
                    tmp[i] =  in.next();

            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    l[i][j] =  tmp[i].charAt(j) == '*' ? 1 : 0;
                }
            }
            set = new HashSet<Pair<Integer, Integer>>();

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (l[i][j] == 1) {
                        calculate(i,j);
                        l[i][j] = set.size()+1;
                        set.clear();
                    }
                }
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    out.print(l[i][j] == 0 ? "." : l[i][j] % 10);
                }
                out.println();
            }
        }

        public void calculate(int i, int j){
            int[] ii = {1, -1, 0, 0};
            int[] jj = {0, 0, -1, 1};

            for (int k = 0; k < 4; k++) {
                int di = i + ii[k];
                int dj = j + jj[k] ;
                if (di < 0 || dj < 0 || di > n-1 || dj > m-1)continue;

                Pair<Integer, Integer> pair = new Pair<Integer, Integer>(di,dj);
                if (l[di][dj] > 0 || set.contains(pair)) continue;
                set.add(pair);
                calculate(di, dj);
            }
        }
    }

    static class InputReader {
        public StringTokenizer tokenizer;
        public BufferedReader reader;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int[] nextInts(int n) throws IOException {
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = nextInt();
            }
            return res;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import javafx.util.Pair;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        int[][] l = new int[1002][1002];
        int n, m, num = 2;
        Map<Integer,Integer> numbs;
        HashSet<Pair<Integer,Integer>> set;
        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            n = in.nextInt();
            m = in.nextInt();
            String[] tmp = new String[1002];
            for (int i = 0; i < n; i++) {
                    tmp[i] =  in.next();

            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    l[i][j] =  tmp[i].charAt(j) == '*' ? 1 : 0;
                }
            }
            set = new HashSet<Pair<Integer, Integer>>();
            numbs = new HashMap<Integer, Integer>() ;

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (l[i][j] == 0) {
                        count(i,j);
                        int value = set.size();
                        set.clear();
                        numbs.put(num, value);
                        fill(i, j, num++);
                        set.clear();
                    }
                }
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    out.print(l[i][j] > 1 ? "." : answer(i,j));
                }
                out.println();
            }
        }

        public int answer(int i, int j){
            int[] ii = {1, -1, 0, 0};
            int[] jj = {0, 0, -1, 1};
            HashSet<Integer> set = new HashSet<Integer>(4);
            int answer = 0;
            for (int k = 0; k < 4; k++) {
                int di = i + ii[k];
                int dj = j + jj[k] ;
                if (di < 0 || dj < 0 || di > n-1 || dj > m-1 || l[di][dj] == 1)continue;
                set.add(l[di][dj]);
            }
            for (Integer v : set) {
                answer += numbs.get(v);
            }
            return (answer+1) % 10;
        }

        public void count(int i, int j){
            int[] ii = {1, -1, 0, 0};
            int[] jj = {0, 0, -1, 1};

            Pair<Integer, Integer> curPair = new Pair<Integer, Integer>(i,j);
            set.add(curPair);
            for (int k = 0; k < 4; k++) {
                int di = i + ii[k];
                int dj = j + jj[k] ;
                if (di < 0 || dj < 0 || di > n-1 || dj > m-1)continue;
                Pair<Integer, Integer> pair = new Pair<Integer, Integer>(di,dj);
                if (l[di][dj] == 1 || set.contains(pair)) continue;
                set.add(pair);
                count(di, dj);
            }

        }

        public void fill(int i, int j, int value){
            int[] ii = {1, -1, 0, 0};
            int[] jj = {0, 0, -1, 1};

            Pair<Integer, Integer> curPair = new Pair<Integer, Integer>(i,j);
            set.add(curPair);
            l[i][j] = value;
            for (int k = 0; k < 4; k++) {
                int di = i + ii[k];
                int dj = j + jj[k] ;
                if (di < 0 || dj < 0 || di > n-1 || dj > m-1)continue;
                Pair<Integer, Integer> pair = new Pair<Integer, Integer>(di,dj);
                if (l[di][dj] == 1 || set.contains(pair)) continue;
                set.add(pair);
                fill(di, dj, value);
            }
        }

    }

    static class InputReader {
        public StringTokenizer tokenizer;
        public BufferedReader reader;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int[] nextInts(int n) throws IOException {
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = nextInt();
            }
            return res;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import javafx.util.Pair;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        static int[][] l = new int[1002][1002];
        static char[][] t;
        static int n, m, num = 2;
        static int[] numbs;
        HashSet<Pair<Integer,Integer>> set;
        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            n = in.nextInt();
            m = in.nextInt();
            numbs = new int[n*m + 5];
            numbs[0] = 0;
            t = new char[n + 2][m + 2];
            Arrays.fill( t[0], '*' );
            Arrays.fill( t[n + 1], '*' );
            for ( int i = 1; i <= n; i ++ ) {
                t[i] = ( "*" + in.next() + "*" ).toCharArray();
            }

            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    if (l[i][j] == 0 && t[i][j] == '.') {
                        numbs[++num] = fill(i,j);
                    }
                }
            }

            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    //out.print(l[i][j] +  " ");
                    out.print(l[i][j] > 0 ? "." : answer(i,j));
                }
                out.println();
            }

        }

        public int fill(int i, int j){
            if (t[i][j] == '*' || l[i][j] > 0) return 0;
            l[i][j] = num;
            int ans = 1;
            ans += fill(i-1,j) + fill(i+1,j) + fill(i,j-1) + fill(i,j+1);
            return ans;
        }

        public int answer(int i, int j){
            HashSet<Integer> set = new HashSet<Integer>(4);
            int answer = 0;
            set.add(l[i+1][j]);
            set.add(l[i-1][j]);
            set.add(l[i][j-1]);
            set.add(l[i][j+1]);
            for (Integer v : set) {
                answer += numbs[v];
            }
            return (answer+1) % 10;
        }

    }

    static class InputReader {
        public StringTokenizer tokenizer;
        public BufferedReader reader;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int[] nextInts(int n) throws IOException {
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = nextInt();
            }
            return res;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import javafx.util.Pair;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        int[][] l = new int[1002][1002];
        int n, m;
        HashSet<Pair<Integer,Integer>> set;
        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            n = in.nextInt();
            m = in.nextInt();
            String[] tmp = new String[1002];
            for (int i = 0; i < n; i++) {
                    tmp[i] =  in.next();

            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    l[i][j] =  tmp[i].charAt(j) == '*' ? 1 : 0;
                }
            }
            set = new HashSet<Pair<Integer, Integer>>();

            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (l[i][j] == 1) {
                        calculate(i,j);
                        out.println(i + " "  + j + " " + (set.size()+1));
                        l[i][j] = set.size()+1;
                        set.clear();
                    }
                }
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    out.print(l[i][j] == 0 ? "." : l[i][j] % 10);
                }
                out.println();
            }
        }

        public void calculate(int i, int j){
            int[] ii = {1, -1, 0, 0};
            int[] jj = {0, 0, -1, 1};

            for (int k = 0; k < 4; k++) {
                int di = i + ii[k];
                int dj = j + jj[k] ;
                if (di < 0 || dj < 0 || di > n-1 || dj > m-1)continue;

                Pair<Integer, Integer> pair = new Pair<Integer, Integer>(di,dj);
                if (l[di][dj] > 0 || set.contains(pair)) continue;
                set.add(pair);
                calculate(di, dj);
            }
        }
    }

    static class InputReader {
        public StringTokenizer tokenizer;
        public BufferedReader reader;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int[] nextInts(int n) throws IOException {
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = nextInt();
            }
            return res;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import javafx.util.Pair;

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.*;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {
    public static void main(String[] args) throws IOException{
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        Task solver = new Task();
        solver.solve(1, in, out);
        out.close();
    }

    static class Task {
        static int[][] l = new int[1002][1002];
        static char[][] t;
        static int n, m, num = 2;
        static int[] numbs;
        HashSet<Pair<Integer,Integer>> set;
        public void solve(int testNumber, InputReader in, PrintWriter out) throws IOException {
            n = in.nextInt();
            m = in.nextInt();
            numbs = new int[n*m];
            numbs[0] = 0;
            t = new char[n + 2][m + 2];
            Arrays.fill( t[0], '*' );
            Arrays.fill( t[n + 1], '*' );
            for ( int i = 1; i <= n; i ++ ) {
                t[i] = ( "*" + in.next() + "*" ).toCharArray();
            }

            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    if (l[i][j] == 0 && t[i][j] == '.') {
                        numbs[++num] = fill(i,j);
                    }
                }
            }

            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= m; j++) {
                    //out.print(l[i][j] +  " ");
                    out.print(l[i][j] > 0 ? "." : answer(i,j));
                }
                out.println();
            }

        }

        public int fill(int i, int j){
            if (t[i][j] == '*' || l[i][j] > 0) return 0;
            l[i][j] = num;
            int ans = 1;
            ans += fill(i-1,j) + fill(i+1,j) + fill(i,j-1) + fill(i,j+1);
            return ans;
        }

        public int answer(int i, int j){
            HashSet<Integer> set = new HashSet<Integer>(4);
            int answer = 0;
            set.add(l[i+1][j]);
            set.add(l[i-1][j]);
            set.add(l[i][j-1]);
            set.add(l[i][j+1]);
            for (Integer v : set) {
                answer += numbs[v];
            }
            return (answer+1) % 10;
        }

    }

    static class InputReader {
        public StringTokenizer tokenizer;
        public BufferedReader reader;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int[] nextInts(int n) throws IOException {
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = nextInt();
            }
            return res;
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }

    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.HashSet;
import java.util.Queue;
import java.util.Set;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        String[] split = in.readLine().split(" ");
        int N = Integer.parseInt(split[0]);
        int M = Integer.parseInt(split[1]);

        String[] matrix = new String[N];
        for(int i = 0; i < N; i++) {
            matrix[i] = in.readLine();
        }

        Solution solution = new Solution(N, M, matrix);
        solution.solve();
        for(int i = 0; i < N; i++) {
            for(int j = 0; j < M; j++) {
                if(matrix[i].charAt(j) == '*') {
                    out.print(solution.getAnswerFor(i, j));
                } else {
                    out.print('.');
                }
            }
            out.println();
        }

        in.close();
        out.close();
    }

    public static final class Solution {
        private static final int[] dX = {-1, 0, 0, 1};
        private static final int[] dY = {0, -1, 1, 0};

        private int N;
        private int M;
        private int[][] connectedComponent;
        private String[] matrix;
        private int[] componentSize = new int[1000010];
        private int currentComponent;

        public Solution(int N, int M, String[] matrix) {
            this.N = N;
            this.M = M;
            this.matrix = matrix;
            connectedComponent = new int[matrix.length][matrix[0].length()];
        }

        public void solve() {
            for(int i = 0; i < N; i++) {
                for(int j = 0; j < M; j++) {
                    if(matrix[i].charAt(j) == '.' && connectedComponent[i][j] == 0) {
                        connectedComponent[i][j] = ++currentComponent;
                        DFS(i, j);
                    }
                }
            }
        }

        public int getAnswerFor(int x, int y) {
            Set<Integer> neighbors = new HashSet<>();
            for(int i = 0; i < 4; i++) {
                int nextX = x + dX[i];
                int nextY = y + dY[i];
                if (nextX >= 0 && nextY >= 0 && nextX < N && nextY < M) {
                    neighbors.add(connectedComponent[nextX][nextY]);
                }
            }
            int answer = 1;
            for(Integer v: neighbors) {
                answer = answer + componentSize[v];
            }
            return answer % 10;
        }

        private void DFS(int x, int y) {
            Queue<Pair> q = new ArrayDeque<>();
            q.add(new Pair(x, y));
            while(q.isEmpty() == false) {
                Pair p = q.poll();
                componentSize[currentComponent]++;
                for (int i = 0; i < 4; i++) {
                    int nextX = p.x + dX[i];
                    int nextY = p.y + dY[i];
                    if (nextX >= 0 && nextY >= 0 && nextX < N && nextY < M) {
                        if (matrix[nextX].charAt(nextY) == '.' && connectedComponent[nextX][nextY] == 0) {
                            connectedComponent[nextX][nextY] = currentComponent;
                            q.add(new Pair(nextX, nextY));
                        }
                    }
                }
            }
        }

    }

    public static final class Pair {
        int x;
        int y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.HashSet;
import java.util.Set;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        String[] split = in.readLine().split(" ");
        int N = Integer.parseInt(split[0]);
        int M = Integer.parseInt(split[1]);

        String[] matrix = new String[N];
        for(int i = 0; i < N; i++) {
            matrix[i] = in.readLine();
        }

        Solution solution = new Solution(N, M, matrix);
        solution.solve();
        for(int i = 0; i < N; i++) {
            for(int j = 0; j < M; j++) {
                if(matrix[i].charAt(j) == '*') {
                    out.print(solution.getAnswerFor(i, j));
                } else {
                    out.print('.');
                }
            }
            out.println();
        }

        in.close();
        out.close();
    }

    public static final class Solution {
        private static final int[] dX = {-1, 0, 0, 1};
        private static final int[] dY = {0, -1, 1, 0};

        private int N;
        private int M;
        private int[][] connectedComponent;
        private String[] matrix;
        private int[] componentSize = new int[1000010];
        private int currentComponent;

        public Solution(int N, int M, String[] matrix) {
            this.N = N;
            this.M = M;
            this.matrix = matrix;
            connectedComponent = new int[matrix.length][matrix[0].length()];
        }

        public void solve() {
            for(int i = 0; i < N; i++) {
                for(int j = 0; j < M; j++) {
                    if(matrix[i].charAt(j) == '.' && connectedComponent[i][j] == 0) {
                        connectedComponent[i][j] = ++currentComponent;
                        DFS(i, j);
                    }
                }
            }
        }

        public int getAnswerFor(int x, int y) {
            Set<Integer> neighbors = new HashSet<>();
            for(int i = 0; i < 4; i++) {
                int nextX = x + dX[i];
                int nextY = y + dY[i];
                if (nextX >= 0 && nextY >= 0 && nextX < N && nextY < M) {
                    neighbors.add(connectedComponent[nextX][nextY]);
                }
            }
            int answer = 1;
            for(Integer v: neighbors) {
                answer = answer + componentSize[v];
            }
            return answer % 10;
        }

        private void DFS(int x, int y) {
            componentSize[connectedComponent[x][y]]++;
            for(int i = 0; i < 4; i++) {
                int nextX = x + dX[i];
                int nextY = y + dY[i];
                if(nextX >= 0 && nextY >= 0 && nextX < N && nextY < M) {
                    if(matrix[nextX].charAt(nextY) == '.' && connectedComponent[nextX][nextY] == 0) {
                        connectedComponent[nextX][nextY] = connectedComponent[x][y];
                        DFS(nextX, nextY);
                    }
                }
            }
        }

    }
}


import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.HashSet;
import java.util.Queue;
import java.util.Set;

public class Main {

    public static void main(String[] args) throws Exception {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(System.out);

        String[] split = in.readLine().split(" ");
        int N = Integer.parseInt(split[0]);
        int M = Integer.parseInt(split[1]);

        String[] matrix = new String[N];
        for(int i = 0; i < N; i++) {
            matrix[i] = in.readLine();
        }

        Solution solution = new Solution(N, M, matrix);
        solution.solve();
        for(int i = 0; i < N; i++) {
            for(int j = 0; j < M; j++) {
                if(matrix[i].charAt(j) == '*') {
                    out.print(solution.getAnswerFor(i, j));
                } else {
                    out.print('.');
                }
            }
            out.println();
        }

        in.close();
        out.close();
    }

    public static final class Solution {
        private static final int[] dX = {-1, 0, 0, 1};
        private static final int[] dY = {0, -1, 1, 0};

        private int N;
        private int M;
        private int[][] connectedComponent;
        private String[] matrix;
        private int[] componentSize = new int[1000010];
        private int currentComponent;

        public Solution(int N, int M, String[] matrix) {
            this.N = N;
            this.M = M;
            this.matrix = matrix;
            connectedComponent = new int[matrix.length][matrix[0].length()];
        }

        public void solve() {
            for(int i = 0; i < N; i++) {
                for(int j = 0; j < M; j++) {
                    if(matrix[i].charAt(j) == '.' && connectedComponent[i][j] == 0) {
                        ++currentComponent;
                        DFS(i, j);
                    }
                }
            }
        }

        public int getAnswerFor(int x, int y) {
            Set<Integer> neighbors = new HashSet<>();
            for(int i = 0; i < 4; i++) {
                int nextX = x + dX[i];
                int nextY = y + dY[i];
                if (nextX >= 0 && nextY >= 0 && nextX < N && nextY < M) {
                    neighbors.add(connectedComponent[nextX][nextY]);
                }
            }
            int answer = 1;
            for(Integer v: neighbors) {
                answer = answer + componentSize[v];
            }
            return answer % 10;
        }

        private void DFS(int x, int y) {
            Queue<Pair> q = new ArrayDeque<>();
            q.add(new Pair(x, y));
            while(q.isEmpty() == false) {
                Pair p = q.poll();
                componentSize[currentComponent]++;
                connectedComponent[p.x][p.y] = currentComponent;
                for (int i = 0; i < 4; i++) {
                    int nextX = p.x + dX[i];
                    int nextY = p.y + dY[i];
                    if (nextX >= 0 && nextY >= 0 && nextX < N && nextY < M) {
                        if (matrix[nextX].charAt(nextY) == '.' && connectedComponent[nextX][nextY] == 0) {
                            q.add(new Pair(nextX, nextY));
                        }
                    }
                }
            }
        }

    }

    public static final class Pair {
        int x;
        int y;

        Pair(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.*;

public class P616C_dfs {
    static long mod=1000000007;
    static int s[][];
    static Pair p[][];
    static boolean b[][];
    static int a[][];
    static int n,m;
    static int dfs(int i,int j,Pair d)
    {
        int c=1;
        b[i][j]=true;
        p[i][j]=d;
        if(i-1>=0&&a[i-1][j]==1&&!b[i-1][j])
        {
            c+=dfs(i-1,j,d);
        }
        if(j-1>=0&&a[i][j-1]==1&&!b[i][j-1])
        {
            c+=dfs(i,j-1,d);
        }
        if(i+1<n&&a[i+1][j]==1&&!b[i+1][j])
        {
            c+=dfs(i+1,j,d);
        }
        if(j+1<m&&a[i][j+1]==1&&!b[i][j+1])
        {
            c+=dfs(i,j+1,d);
        }
        s[i][j]=c;
        return c;
    }
    public static void main(String[] args) throws Exception{
         InputReader in = new InputReader(System.in);
        PrintWriter pw=new PrintWriter(System.out);
             n=in.readInt();
             m=in.readInt();
        char c[][]=new char[n][m];
        a=new int[n][m];
        p=new Pair[n][m];
        s=new int[n][m];
        b=new boolean[n][m];

        for(int i=0;i<n;i++)
        {
            String x=in.readString();
            c[i]=x.toCharArray();
            for(int j=0;j<m;j++)
            {
                if(c[i][j]=='.')
                {
                    a[i][j]=1;
                    Pair d=new Pair(i,j);
                    p[i][j]=d;
                    s[i][j]=1;
                }

            }
        }

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]==1&&!b[i][j])
                {

                    Pair d=new Pair(i,j);
                    dfs(i,j,d);
                }
            }
        }
        String t="";
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]==0)
                {
                    int ans=1;
                    int d=0,e=0,f=0,g=0;
                    HashSet<Pair>hs=new HashSet<Pair>();
                    if(i+1<n&&a[i+1][j]==1)
                    {
                        Pair x=p[i+1][j];
                        //Pair x=find(i+1,j);
                        d=s[x.a][x.b];
                         hs.add(x);

                    }
                    if(j+1<m&&a[i][j+1]==1)
                    {
                        Pair x=p[i][j+1];
                        //Pair x=find(i,j+1);
                        if(!hs.contains(p[i][j+1]))
                        {
                            e=s[x.a][x.b];
                             hs.add(x);
                        }
                    }
                    if(i-1>=0&&a[i-1][j]==1)
                    {
                        Pair x=p[i-1][j];
                        //Pair x=find(i-1,j);
                        if(!hs.contains(p[i-1][j]))
                        {
                            f=s[x.a][x.b];
                             hs.add(x);
                        }
                    }
                    if(j-1>=0&&a[i][j-1]==1)
                    {
                        Pair x=p[i][j-1];
                        //Pair x=find(i,j-1);
                        if(!hs.contains(p[i][j-1]))
                        {
                            g=s[x.a][x.b];
                             hs.add(x);
                        }
                    }
                    ans+=d+e+f+g;

                    pw.print(ans%10);

                }
                else
                    pw.print(c[i][j]);
            }
            pw.println(" ");
        }

    //   System.out.println(p[0][3]+" "+p[0][1]+" "+p[3][1]+" "+p[1][1]);

        pw.close();
    }

    public static long  ways(int n, int r, long MOD)
    {
      //  vector<long long> f(n + 1,1);
        long f[]=new long[n+1];
        Arrays.fill(f,1);
        for (int i=2; i<=n;i++)
            f[i]= (f[i-1]*i) % MOD;
        return (f[n]*((InverseEuler(f[r], MOD) * InverseEuler(f[n-r], MOD)) % MOD)) % MOD;
    }
    public static long  InverseEuler(long n, long MOD)
    {
        return pow(n,MOD-2,MOD);
    }
    static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        if (number <= 3) {
            return true;
        }
        if (number % 2 == 0 || number % 3 == 0) {
            return false;
        }
        int i = 5;
        while (i * i <= number) {
            if (number % i == 0 || number % (i + 2) == 0) {
                return false;
            }
            i += 6;
        }
        return true;
    }

public static long gcd(long x,long y)
{
    if(x%y==0)
        return y;
    else
        return gcd(y,x%y);
}

public static int gcd(int x,int y)
{
    if(x%y==0)
        return y;
    else
        return gcd(y,x%y);
}
public static int abs(int a,int b)
{
    return (int)Math.abs(a-b);
}
public static long abs(long a,long b)
{
    return (long)Math.abs(a-b);
}
public static int max(int a,int b)
{
    if(a>b)
        return a;
    else
        return b;
}
public static int min(int a,int b)
{
    if(a>b)
        return b;
    else
        return a;
}
public static long max(long a,long b)
{
    if(a>b)
        return a;
    else
        return b;
}
public static long min(long a,long b)
{
    if(a>b)
        return b;
    else
        return a;
}

static boolean isPowerOfTwo (long v) {
    return (v & (v - 1)) == 0;
}
public static long pow(long n,long p,long m)
{
     long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;
        if(result>=m)
        result%=m;
        p >>=1;
        n*=n;
        if(n>=m)
        n%=m;
    }
    return result;
}
public static long pow(long n,long p)
{
    long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;
        p >>=1;
        n*=n;
    }
    return result;

}
static class Pair implements Comparable<Pair>
{
    int a,b;
    Pair (int a,int b)
    {
        this.a=a;
        this.b=b;
    }

    public int compareTo(Pair o) {
        // TODO Auto-generated method stub
        if(this.a!=o.a)
        return Integer.compare(this.a,o.a);
        else
            return Integer.compare(this.b, o.b);
        //return 0;
    }
    public boolean equals(Object o) {
        if (o instanceof Pair) {
            Pair p = (Pair)o;
            return p.a == a && p.b == b;
        }
        return false;
    }
    public int hashCode() {
        return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
    }
}

static long sort(int a[],int n)
{   int b[]=new int[n];
    return mergeSort(a,b,0,n-1);}
static long mergeSort(int a[],int b[],long left,long right)
{ long c=0;if(left<right)
 {   long mid=left+(right-left)/2;
     c= mergeSort(a,b,left,mid);
     c+=mergeSort(a,b,mid+1,right);
     c+=merge(a,b,left,mid+1,right); }
    return c;    }
static long merge(int a[],int  b[],long left,long mid,long right)
{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
while(i<=(int)mid-1&&j<=(int)right)
{ if(a[i]<=a[j]) {b[k++]=a[i++]; }
else    { b[k++]=a[j++];c+=mid-i;}}
while (i <= (int)mid - 1)   b[k++] = a[i++];
while (j <= (int)right) b[k++] = a[j++];
for (i=(int)left; i <= (int)right; i++)
    a[i] = b[i];  return c;  }

   static  class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream)
        {
            this.stream = stream;
        }

        public int read()
        {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars)
            {
                curChar = 0;
                try
                {
                    numChars = stream.read(buf);
                } catch (IOException e)
                {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int readInt()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String readString()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
        public double readDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, readInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
        public long readLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public boolean isSpaceChar(int c)
        {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next()
        {
            return readString();
        }

        public interface SpaceCharFilter
        {
            public boolean isSpaceChar(int ch);
        }
    }

     static class OutputWriter
    {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream)
        {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer)
        {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects)
        {
            for (int i = 0; i < objects.length; i++)
            {
                if (i != 0)
                    writer.print(' ');
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects)
        {
            print(objects);
            writer.println();
        }

        public void close()
        {
            writer.close();
        }

        public void flush()
        {
            writer.flush();
        }

    }
    /* USAGE

    //initialize
        InputReader in      = new InputReader(System.in);
        OutputWriter out    =   new OutputWriter(System.out);

    //read int
    int i = in.readInt();
    //read string
    String s = in.readString();
    //read int array of size N
    int[] x = IOUtils.readIntArray(in,N);
    //printline
    out.printLine("X");

    //flush output
    out.flush();

    //remember to close the
    //outputstream, at the end
    out.close();

    */
  static   class IOUtils {

        public static int[] readIntArray(InputReader in, int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
                array[i] = in.readInt();
            return array;
    }
    }
//BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    //StringBuilder sb=new StringBuilder("");
     //InputReader in = new InputReader(System.in);
  // OutputWriter out = new OutputWriter(System.out);
    //PrintWriter pw=new PrintWriter(System.out);
    //String line=br.readLine().trim();

    //int t=Integer.parseInt(br.readLine());
  //    while(t-->0)
    //{
    //int n=Integer.parseInt(br.readLine());
    //long n=Long.parseLong(br.readLine());
    //String l[]=br.readLine().split(" ");
  //int m=Integer.parseInt(l[0]);
    //int k=Integer.parseInt(l[1]);
    //String l[]=br.readLine().split(" ");
    //l=br.readLine().split(" ");
    /*int a[]=new int[n];
    for(int i=0;i<n;i++)
    {
        a[i]=Integer.parseInt(l[i]);
    }*/
       //System.out.println(" ");

    //}
}


import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
import java.lang.*;

public class P616C {
    static long mod=1000000007;
    static int s[][];
    static Pair p[][];
    static boolean b[][];
    public static Pair find(int i,int j)
    {
        //Pair x=new Pair(i,j);
        if(p[i][j].a==i&&p[i][j].b==j)
        //if(p[i][j]==x)
            return p[i][j];
        Pair result=find(p[i][j].a,p[i][j].b);
        p[i][j]=result;
        return result;
    }
    public static void union(int x,int y,int x1,int y1)
    {
        Pair xp=find(x,y);
        Pair yp=find(x1,y1);
        if(xp!=yp)
        {
            Pair d=new Pair(yp.a,yp.b);
            p[xp.a][xp.b]=d;
            //p[x][y]=yp;
            //p[xp.a][xp.b]=yp;
            s[yp.a][yp.b]+=s[xp.a][xp.b];

        }
    }
    public static void main(String[] args) throws Exception{
         InputReader in = new InputReader(System.in);
        PrintWriter pw=new PrintWriter(System.out);

            int n=in.readInt();
            int m=in.readInt();
        char c[][]=new char[n][m];
        int a[][]=new int[n][m];
        p=new Pair[n][m];
        s=new int[n][m];
        //b=new boolean[n][m];

        for(int i=0;i<n;i++)
        {
            String x=in.readString();
            c[i]=x.toCharArray();
            for(int j=0;j<m;j++)
            {
                if(c[i][j]=='.')
                {
                    a[i][j]=1;
                    Pair d=new Pair(i,j);
                    p[i][j]=d;
                    s[i][j]=1;
                }

            }
        }

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]==1)
                {
                    if(i-1>=0&&a[i-1][j]==1)
                    {
                        if(p[i][j].a<p[i-1][j].a)
                         union(i-1,j,i,j);
                        else if(p[i][j].a==p[i-1][j].a&&p[i][j].b<p[i-1][j].b)
                             union(i-1,j,i,j);
                        else
                            union(i,j,i-1,j);

                    }
                    if(j-1>=0&&a[i][j-1]==1)
                    {
                        if(p[i][j].a<p[i][j-1].a)
                             union(i,j-1,i,j);
                            else if(p[i][j].a==p[i][j-1].a&&p[i][j].b<p[i][j-1].b)
                                 union(i,j-1,i,j);
                            else
                                union(i,j,i,j-1);
                    }
                    if(i+1<n&&a[i+1][j]==1)
                    {
                        if(p[i][j].a<p[i+1][j].a)
                         union(i+1,j,i,j);
                        else if(p[i][j].a==p[i+1][j].a&&p[i][j].b<p[i+1][j].b)
                             union(i+1,j,i,j);
                        else
                            union(i,j,i+1,j);
                    }
                    if(j+1<m&&a[i][j+1]==1)
                    {
                        if(p[i][j].a<p[i][j+1].a)
                         union(i,j+1,i,j);
                        else if(p[i][j].a==p[i][j+1].a&&p[i][j].b<p[i][j+1].b)
                             union(i,j+1,i,j);
                        else
                            union(i,j,i,j+1);
                    }

                }
            }
        }
        String t="";
        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                if(a[i][j]==0)
                {
                    int d=0,e=0,f=0,g=0;
                    boolean d1=false;
                    boolean d2,d3,d4;
                    d2=d3=d4=d1;
                    int ans=1;
                    HashSet<Pair>hs=new HashSet<Pair>();
                    if(i+1<n&&a[i+1][j]==1)
                    {
                        //Pair x=p[i+1][j];
                        Pair x=find(i+1,j);
                        d=s[x.a][x.b];
                         hs.add(x);
                    }
                    if(j+1<m&&a[i][j+1]==1)
                    {
                        //Pair x=p[i][j+1];
                        Pair x=find(i,j+1);
                        if(!hs.contains(p[i][j+1]))
                        {
                            e=s[x.a][x.b];
                             hs.add(x);
                        }
                    }
                    if(i-1>=0&&a[i-1][j]==1)
                    {
                        //Pair x=p[i-1][j];
                        Pair x=find(i-1,j);
                        if(!hs.contains(p[i-1][j]))
                        {
                            f=s[x.a][x.b];
                             hs.add(x);
                        }
                    }
                    if(j-1>=0&&a[i][j-1]==1)
                    {
                        //Pair x=p[i][j-1];
                        Pair x=find(i,j-1);
                        if(!hs.contains(p[i][j-1]))
                        {
                            g=s[x.a][x.b];
                             hs.add(x);
                        }
                    }
                    ans+=d+e+f+g;
                    /*if(i==0&&j==2)
                    {
                        System.out.println(d+" "+e+" "+f+" "+g);
                    }*/
                    pw.print(ans%10);

                }
                else
                    pw.print(c[i][j]);
            }
            pw.println(" ");
        }

    //   System.out.println(p[0][3]+" "+p[0][1]+" "+p[3][1]+" "+p[1][1]);

        pw.close();
    }

    public static long  ways(int n, int r, long MOD)
    {
      //  vector<long long> f(n + 1,1);
        long f[]=new long[n+1];
        Arrays.fill(f,1);
        for (int i=2; i<=n;i++)
            f[i]= (f[i-1]*i) % MOD;
        return (f[n]*((InverseEuler(f[r], MOD) * InverseEuler(f[n-r], MOD)) % MOD)) % MOD;
    }
    public static long  InverseEuler(long n, long MOD)
    {
        return pow(n,MOD-2,MOD);
    }
    static boolean isPrime(int number) {
        if (number <= 1) {
            return false;
        }
        if (number <= 3) {
            return true;
        }
        if (number % 2 == 0 || number % 3 == 0) {
            return false;
        }
        int i = 5;
        while (i * i <= number) {
            if (number % i == 0 || number % (i + 2) == 0) {
                return false;
            }
            i += 6;
        }
        return true;
    }

public static long gcd(long x,long y)
{
    if(x%y==0)
        return y;
    else
        return gcd(y,x%y);
}

public static int gcd(int x,int y)
{
    if(x%y==0)
        return y;
    else
        return gcd(y,x%y);
}
public static int abs(int a,int b)
{
    return (int)Math.abs(a-b);
}
public static long abs(long a,long b)
{
    return (long)Math.abs(a-b);
}
public static int max(int a,int b)
{
    if(a>b)
        return a;
    else
        return b;
}
public static int min(int a,int b)
{
    if(a>b)
        return b;
    else
        return a;
}
public static long max(long a,long b)
{
    if(a>b)
        return a;
    else
        return b;
}
public static long min(long a,long b)
{
    if(a>b)
        return b;
    else
        return a;
}

static boolean isPowerOfTwo (long v) {
    return (v & (v - 1)) == 0;
}
public static long pow(long n,long p,long m)
{
     long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;
        if(result>=m)
        result%=m;
        p >>=1;
        n*=n;
        if(n>=m)
        n%=m;
    }
    return result;
}
public static long pow(long n,long p)
{
    long  result = 1;
      if(p==0)
        return 1;
    if (p==1)
        return n;
    while(p!=0)
    {
        if(p%2==1)
            result *= n;
        p >>=1;
        n*=n;
    }
    return result;

}
static class Pair implements Comparable<Pair>
{
    int a,b;
    Pair (int a,int b)
    {
        this.a=a;
        this.b=b;
    }

    public int compareTo(Pair o) {
        // TODO Auto-generated method stub
        if(this.a!=o.a)
        return Integer.compare(this.a,o.a);
        else
            return Integer.compare(this.b, o.b);
        //return 0;
    }
    public boolean equals(Object o) {
        if (o instanceof Pair) {
            Pair p = (Pair)o;
            return p.a == a && p.b == b;
        }
        return false;
    }
    public int hashCode() {
        return new Integer(a).hashCode() * 31 + new Integer(b).hashCode();
    }
}

static long sort(int a[],int n)
{   int b[]=new int[n];
    return mergeSort(a,b,0,n-1);}
static long mergeSort(int a[],int b[],long left,long right)
{ long c=0;if(left<right)
 {   long mid=left+(right-left)/2;
     c= mergeSort(a,b,left,mid);
     c+=mergeSort(a,b,mid+1,right);
     c+=merge(a,b,left,mid+1,right); }
    return c;    }
static long merge(int a[],int  b[],long left,long mid,long right)
{long c=0;int i=(int)left;int j=(int)mid; int k=(int)left;
while(i<=(int)mid-1&&j<=(int)right)
{ if(a[i]<=a[j]) {b[k++]=a[i++]; }
else    { b[k++]=a[j++];c+=mid-i;}}
while (i <= (int)mid - 1)   b[k++] = a[i++];
while (j <= (int)right) b[k++] = a[j++];
for (i=(int)left; i <= (int)right; i++)
    a[i] = b[i];  return c;  }

   static  class InputReader
    {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;

        public InputReader(InputStream stream)
        {
            this.stream = stream;
        }

        public int read()
        {
            if (numChars == -1)
                throw new InputMismatchException();
            if (curChar >= numChars)
            {
                curChar = 0;
                try
                {
                    numChars = stream.read(buf);
                } catch (IOException e)
                {
                    throw new InputMismatchException();
                }
                if (numChars <= 0)
                    return -1;
            }
            return buf[curChar++];
        }

        public int readInt()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-')
            {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do
            {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public String readString()
        {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            StringBuilder res = new StringBuilder();
            do
            {
                res.appendCodePoint(c);
                c = read();
            } while (!isSpaceChar(c));
            return res.toString();
        }
        public double readDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, readInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, readInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }
        public long readLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long res = 0;
            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }
        public boolean isSpaceChar(int c)
        {
            if (filter != null)
                return filter.isSpaceChar(c);
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public String next()
        {
            return readString();
        }

        public interface SpaceCharFilter
        {
            public boolean isSpaceChar(int ch);
        }
    }

     static class OutputWriter
    {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream)
        {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer)
        {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects)
        {
            for (int i = 0; i < objects.length; i++)
            {
                if (i != 0)
                    writer.print(' ');
                writer.print(objects[i]);
            }
        }

        public void printLine(Object... objects)
        {
            print(objects);
            writer.println();
        }

        public void close()
        {
            writer.close();
        }

        public void flush()
        {
            writer.flush();
        }

    }
    /* USAGE

    //initialize
        InputReader in      = new InputReader(System.in);
        OutputWriter out    =   new OutputWriter(System.out);

    //read int
    int i = in.readInt();
    //read string
    String s = in.readString();
    //read int array of size N
    int[] x = IOUtils.readIntArray(in,N);
    //printline
    out.printLine("X");

    //flush output
    out.flush();

    //remember to close the
    //outputstream, at the end
    out.close();

    */
  static   class IOUtils {

        public static int[] readIntArray(InputReader in, int size) {
            int[] array = new int[size];
            for (int i = 0; i < size; i++)
                array[i] = in.readInt();
            return array;
    }
    }
//BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
    //StringBuilder sb=new StringBuilder("");
     //InputReader in = new InputReader(System.in);
  // OutputWriter out = new OutputWriter(System.out);
    //PrintWriter pw=new PrintWriter(System.out);
    //String line=br.readLine().trim();

    //int t=Integer.parseInt(br.readLine());
  //    while(t-->0)
    //{
    //int n=Integer.parseInt(br.readLine());
    //long n=Long.parseLong(br.readLine());
    //String l[]=br.readLine().split(" ");
  //int m=Integer.parseInt(l[0]);
    //int k=Integer.parseInt(l[1]);
    //String l[]=br.readLine().split(" ");
    //l=br.readLine().split(" ");
    /*int a[]=new int[n];
    for(int i=0;i<n;i++)
    {
        a[i]=Integer.parseInt(l[i]);
    }*/
       //System.out.println(" ");

    //}
}