import sys
import pypyjit
H, W = map(int, input().split())
S = [list(input()) for _ in range(H)]

pypyjit.set_param('max_unroll_recursion=-1')
sys.setrecursionlimit(2000000)


class dsu():
    n = 1
    parent_or_size = [-1 for i in range(n)]

    def __init__(self, N):
        self.n = N
        self.parent_or_size = [-1 for i in range(N)]

    def merge(self, a, b):
        assert 0 <= a < self.n, "0<=a<n,a={0},n={1}".format(a, self.n)
        assert 0 <= b < self.n, "0<=b<n,b={0},n={1}".format(b, self.n)
        x = self.leader(a)
        y = self.leader(b)
        if x == y:
            return x
        if (-self.parent_or_size[x] < -self.parent_or_size[y]):
            x, y = y, x
        self.parent_or_size[x] += self.parent_or_size[y]
        self.parent_or_size[y] = x
        return x

    def same(self, a, b):
        assert 0 <= a < self.n, "0<=a<n,a={0},n={1}".format(a, self.n)
        assert 0 <= b < self.n, "0<=b<n,b={0},n={1}".format(b, self.n)
        return self.leader(a) == self.leader(b)

    def leader(self, a):
        assert 0 <= a < self.n, "0<=a<n,a={0},n={1}".format(a, self.n)
        if (self.parent_or_size[a] < 0):
            return a
        self.parent_or_size[a] = self.leader(self.parent_or_size[a])
        return self.parent_or_size[a]

    def size(self, a):
        assert 0 <= a < self.n, "0<=a<n,a={0},n={1}".format(a, self.n)
        return -self.parent_or_size[self.leader(a)]

    def groups(self):
        leader_buf = [0 for i in range(self.n)]
        group_size = [0 for i in range(self.n)]
        for i in range(self.n):
            leader_buf[i] = self.leader(i)
            group_size[leader_buf[i]] += 1
        result = [[] for i in range(self.n)]
        for i in range(self.n):
            result[leader_buf[i]].append(i)
        result2 = []
        for i in range(self.n):
            if len(result[i]) > 0:
                result2.append(result[i])
        return result2


dxy = [[1, 0], [-1, 0], [0, 1], [0, -1]]

DSU = dsu(H * W)
for i in range(H):
    for j in range(W):
        if S[i][j] == '.':
            continue
        for dx, dy in dxy:
            ni, nj = i + dx, j + dy
            if 0 <= ni < H and 0 <= nj < W and S[ni][nj] == S[i][j]:
                DSU.merge(i * W + j, ni * W + nj)

# 連結成分のサイズが4以上の場所を.に変える
for g in DSU.groups():
    if len(g) < 4:
        continue
    for i in g:
        S[i // W][i % W] = '.'
print('\n'.join([''.join(s) for s in S]))