```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, m int
	fmt.Fscan(in, &n, &m)

	grid := make([][]byte, n)
	for i := 0; i < n; i++ {
		var s string
		fmt.Fscan(in, &s)
		grid[i] = []byte(s)
	}

	compID := make([][]int, n)
	for i := 0; i < n; i++ {
		compID[i] = make([]int, m)
	}

	compSize := make([]int, 1)
	currID := 0
	dr := []int{0, 0, 1, -1}
	dc := []int{1, -1, 0, 0}
	type pt struct{ r, c int }

	// BFS to find connected components and calculate their sizes
	for r := 0; r < n; r++ {
		for c := 0; c < m; c++ {
			if grid[r][c] == '.' && compID[r][c] == 0 {
				currID++
				compID[r][c] = currID
				q := []pt{{r, c}}
				size := 0
				for i := 0; i < len(q); i++ {
					cur := q[i]
					size++
					for k := 0; k < 4; k++ {
						nr, nc := cur.r+dr[k], cur.c+dc[k]
						if nr >= 0 && nr < n && nc >= 0 && nc < m {
							if grid[nr][nc] == '.' && compID[nr][nc] == 0 {
								compID[nr][nc] = currID
								q = append(q, pt{nr, nc})
							}
						}
					}
				}
				compSize = append(compSize, size)
			}
		}
	}

	// Calculate and print answer for each cell
	for r := 0; r < n; r++ {
		for c := 0; c < m; c++ {
			if grid[r][c] == '.' {
				out.WriteByte('.')
			} else {
				sum := 1
				var seen [4]int
				cnt := 0
				for k := 0; k < 4; k++ {
					nr, nc := r+dr[k], c+dc[k]
					if nr >= 0 && nr < n && nc >= 0 && nc < m {
						if grid[nr][nc] == '.' {
							id := compID[nr][nc]
							found := false
							for x := 0; x < cnt; x++ {
								if seen[x] == id {
									found = true
									break
								}
							}
							if !found {
								sum += compSize[id]
								seen[cnt] = id
								cnt++
							}
						}
					}
				}
				out.WriteByte(byte('0' + sum%10))
			}
		}
		out.WriteByte('\n')
	}
}
```