```go
package main

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

type pair struct {
	x, y int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m int
	fmt.Fscan(in, &n, &m)
	grid := make([]string, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &grid[i])
	}
	assigned := make([][]bool, n)
	group := make([][]int, n)
	degree := make([][]int, n)
	for i := 0; i < n; i++ {
		assigned[i] = make([]bool, m)
		group[i] = make([]int, m)
		degree[i] = make([]int, m)
		for j := 0; j < m; j++ {
			group[i][j] = -1
		}
	}
	dirs := [][]int{{-1, 0}, {1, 0}, {0, -1}, {0, 1}}
	var empties []pair
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			if grid[i][j] == '.' {
				empties = append(empties, pair{i, j})
				for k := 0; k < 4; k++ {
					ni := i + dirs[k][0]
					nj := j + dirs[k][1]
					if ni >= 0 && ni < n && nj >= 0 && nj < m && grid[ni][nj] == '.' {
						degree[i][j]++
					}
				}
			}
		}
	}
	var q []pair
	for _, p := range empties {
		if degree[p.x][p.y] <= 1 {
			q = append(q, p)
		}
	}
	gid := 0
	pidx := 0
	for {
		var l pair
		foundL := false
		if len(q) > 0 {
			l = q[0]
			q = q[1:]
			if assigned[l.x][l.y] {
				continue
			}
			foundL = true
		} else {
			for ; pidx < len(empties); pidx++ {
				cand := empties[pidx]
				if !assigned[cand.x][cand.y] {
					l = cand
					foundL = true
					pidx++
					break
				}
			}
			if !foundL {
				break
			}
		}
		i, j := l.x, l.y
		currdeg := 0
		var ms []pair
		for k := 0; k < 4; k++ {
			ni := i + dirs[k][0]
			nj := j + dirs[k][1]
			if ni >= 0 && ni < n && nj >= 0 && nj < m && grid[ni][nj] == '.' && !assigned[ni][nj] {
				currdeg++
				ms = append(ms, pair{ni, nj})
			}
		}
		if currdeg == 0 {
			fmt.Println(-1)
			return
		}
		mp := ms[0]
		mi, mj := mp.x, mp.y
		var leaves []pair
		for k := 0; k < 4; k++ {
			ni := mi + dirs[k][0]
			nj := mj + dirs[k][1]
			if ni >= 0 && ni < n && nj >= 0 && nj < m && grid[ni][nj] == '.' && !assigned[ni][nj] && !(ni == i && nj == j) {
				if degree[ni][nj] == 1 {
					leaves = append(leaves, pair{ni, nj})
				}
			}
		}
		k := len(leaves)
		if 2+k > 5 {
			fmt.Println(-1)
			return
		}
		gid++
		group[i][j] = gid
		group[mi][mj] = gid
		for _, lf := range leaves {
			group[lf.x][lf.y] = gid
		}
		assigned[i][j] = true
		assigned[mi][mj] = true
		for _, lf := range leaves {
			assigned[lf.x][lf.y] = true
		}
		allgroup := []pair{l, mp}
		allgroup = append(allgroup, leaves...)
		for _, cell := range allgroup {
			ci, cj := cell.x, cell.y
			for kk := 0; kk < 4; kk++ {
				ni := ci + dirs[kk][0]
				nj := cj + dirs[kk][1]
				if ni >= 0 && ni < n && nj >= 0 && nj < m && grid[ni][nj] == '.' && !assigned[ni][nj] {
					degree[ni][nj]--
					if degree[ni][nj] <= 1 {
						q = append(q, pair{ni, nj})
					}
				}
			}
		}
	}
	adj := make([][]int, gid+1)
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			if group[i][j] > 0 {
				g1 := group[i][j]
				for k := 2; k < 4; k++ {
					ni := i + dirs[k][0]
					nj := j + dirs[k][1]
					if ni >= 0 && ni < n && nj >= 0 && nj < m && group[ni][nj] > 0 && group[ni][nj] != g1 {
						g2 := group[ni][nj]
						adj[g1] = append(adj[g1], g2)
						adj[g2] = append(adj[g2], g1)
					}
				}
			}
		}
	}
	color := make([]int, gid+1)
	for g := 1; g <= gid; g++ {
		used := [11]bool{}
		for _, ng := range adj[g] {
			if color[ng] != 0 {
				used[color[ng]] = true
			}
		}
		f := 1
		for ; f <= 10; f++ {
			if !used[f] {
				color[g] = f
				break
			}
		}
		if f > 10 {
			fmt.Println(-1)
			return
		}
	}
	for i := 0; i < n; i++ {
		for j := 0; j < m; j++ {
			if grid[i][j] == '#' {
				fmt.Print("#")
			} else {
				d := color[group[i][j]]
				fmt.Print(string('0' + byte(d-1)))
			}
		}
		fmt.Println()
	}
}
```