#include<cassert>
#include<iostream>
#include<cstdio>
#include<vector>
#include<algorithm>
#include<cmath>
#include<map>
#include<set>
#include<queue>
#include<cstring>
#include<sstream>
#include <tr1/unordered_map>

#define FORE(it, c) for(__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define FC(aa, bb) FORE(bb, aa)
#define debug(x) cerr << #x << " = " << x << endl;
#define debugv(x) cerr << #x << " = " ; FORE(it, (x)) cerr << *it << ", "; cerr << endl;
#define fup(i, a, b) for(int i = (a); i < (b); ++i)
#define fdo(i, a, b) for(int i = (a); i >= (b); --i)
#define FOR fup
#define FORD fdo
#define REP(i, n) for(int i = 0; i < (n); ++i)
#define ALL(x) (x).begin(), (x).end()
#define CLR(x) memset((x), 0, sizeof(x))
#define MP make_pair
#define PB push_back
#define siz(a) ((int)(a).size())
#define SZ siz
#define inf 1000000000
#define FI first
#define SE second

using namespace std;
using namespace tr1;

typedef long long lli;
typedef double ld;
typedef lli LL;
typedef ld LD;
typedef vector<int> VI;
typedef pair<int, int> PII;

const int MAXN = 6010;

VI ve[MAXN];
int sx[MAXN], sy[MAXN], vis[MAXN];

int dfs(int v) {
    vis[v] = 1;
    REP (i, SZ(ve[v])) {
        int k = ve[v][i];
        if (sy[k] == -1 || (!vis[sy[k]] && dfs(sy[k]))) {
            sx[v] = k;
            sy[k] = v;
            return 1;
        }
    }
    return 0;
}

int match(int n, int m) {
    int res = 0, ok = 1;
    REP (i, n) {
        sx[i] = -1;
        vis[i] = 0;
    }
    REP (i, m)
        sy[i] = -1;
    while (ok) {
        ok = 0; memset(vis, 0, sizeof(int) * (n + 1));
        REP (i, n) {
            if (sx[i] == -1 && !vis[i] && dfs(i)) {
                ++res;
                ok = 1;
            }
        }
    }
    return res;
}

VI V; int forb;

int dfs2(int v) {
    vis[v] = 1; V.PB(v);
    REP (i, SZ(ve[v])) {
        int k = ve[v][i];
        if (k == forb)
            continue;
        if (sy[k] == -1 || (!vis[sy[k]] && dfs2(sy[k])))
            return 1;
    }
    return 0;
}

int every[MAXN];

void comp(int N, int M) {
    REP (i, M)
        every[i] = 0;
    REP (i, N)
        vis[i] = 0;
    REP (i, M) {
        if (sy[i] != -1) {
            int k = sy[i];
            sx[k] = -1;
            sy[i] = -1;
            forb = i;
            if (!dfs2(k))
                every[i] = 1;
            FC (V, it)
                vis[*it] = 0;
            V.clear();
            sx[k] = i;
            sy[i] = k;
        }
    }
}

char c[110][110], res[110][110]; int dx[] = {-1,0,1,0}, dy[] = {0,1,0,-1};
int num[110][110];

int main(void) {
    while (1) {
        int n, m; scanf("%d%d", &n, &m);
        if (n == 0 && m == 0)
            break;
        REP (i, n)
            scanf("%s", c[i]);
        int N = 0, M = 0;
        REP (i, n) {
            REP (j, m) {
                if (c[i][j] == 'X') {
                    num[i][j] = -1;
                    res[i][j] = 'X';
                }
                else if (i % 2 == j % 2)
                    num[i][j] = N++;
                else
                    num[i][j] = M++;
            }
            res[i][m] = 0;
        }
        REP (i, N)
            ve[i].clear();
        REP (i, n) {
            REP (j, m) {
                if (num[i][j] == -1 || i % 2 != j % 2)
                    continue;
                REP (k, 4) {
                    int x = i + dx[k], y = j + dy[k];
                    if (num[x][y] != -1)
                        ve[num[i][j]].PB(num[x][y]);
                }
            }
        }
        match(N, M);
        comp(N, M);
        REP (i, n) {
            REP (j, m) {
                if (num[i][j] != -1 && i %2 != j % 2) {
                    if (every[num[i][j]])
                        res[i][j] = 'A';
                    else
                        res[i][j] = 'B';
                }
            }
        }
        N = 0; M = 0;
        REP (i, n) {
            REP (j, m) {
                if (c[i][j] == 'X') {
                    num[i][j] = -1;
                    res[i][j] = 'X';
                }
                else if (i % 2 != j % 2)
                    num[i][j] = N++;
                else
                    num[i][j] = M++;
            }
            res[i][m] = 0;
        }
        REP (i, N)
            ve[i].clear();
        REP (i, n) {
            REP (j, m) {
                if (num[i][j] == -1 || i % 2 == j % 2)
                    continue;
                REP (k, 4) {
                    int x = i + dx[k], y = j + dy[k];
                    if (num[x][y] != -1)
                        ve[num[i][j]].PB(num[x][y]);
                }
            }
        }
        match(N, M);
        comp(N, M);
        REP (i, n) {
            REP (j, m) {
                if (num[i][j] != -1 && i % 2 == j % 2) {
                    if (every[num[i][j]])
                        res[i][j] = 'A';
                    else
                        res[i][j] = 'B';
                }
            }
        }
        REP (i, n)
            puts(res[i]);
        puts("");
    }
    return 0;
}