#include <bits/stdc++.h>
using namespace std;

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;

const int MAXN = 200;

int n,m;

bool ANS[MAXN][MAXN][3] = {0};
bool overlap[MAXN][MAXN] = {0};
bool swapped = 0;
string abc = "ABC";

void print(){
    if(swapped)swap(n,m);
    rep(c1,0,3){
        rep(c2,0,n){
            rep(c3,0,m){
                bool ans = ANS[c2][c3][c1];
                if(swapped)ans = ANS[c3][c2][c1];
                if(ans){
                    cout << abc[c1];
                }
                else{
                    cout << '.';
                }
            }
            cout << "\n";
        }
        cout << "\n";
    }
}

void solve_1d(){
    int segs = 0;
    bool prev = 0;
    rep(c1,0,m){
        if(prev == 0 && overlap[0][c1])segs++;
        prev = overlap[0][c1];
    }
    if(segs > 2 || (segs == 0 && m <= 2)){
        cout << "impossible\n";
        return;
    }
    if(segs == 0){
        rep(c1,0,m-2){
            ANS[0][c1][0] = 1;
        }
        ANS[0][m-2][1] = 1;
        ANS[0][m-1][2] = 1;
    }
    if(segs == 1){
        rep(c1,0,m){
            ANS[0][c1][0] = 1;
            ANS[0][c1][1] = overlap[0][c1];
            ANS[0][c1][2] = overlap[0][c1];
        }
    }
    if(segs == 2){
        bool one = 0;
        bool prev = 0;
        rep(c1,0,m){
            ANS[0][c1][0] = 1;
            if(overlap[0][c1]){
                ANS[0][c1][1] = !one;
                ANS[0][c1][2] = one;
            }
            if(!overlap[0][c1] && prev == 1)one = 1;
            prev = overlap[0][c1];
        }
    }
    print();
    return;
}

int DX[4] = {0,1,0,-1};
int DY[4] = {1,0,-1,0};
int dir[3] = {0};
int covered[MAXN][MAXN] = {0};
int cov = 0;
vector<pii> head(3, pii());

bool inbounds(int i, int j){
    return i >= 0 && j >= 0 && i < n && j < m;
}

void place(int x, int y, int i){
    if(covered[x][y] == 0){
        cov++;
        ANS[x][y][i] = 1;
        covered[x][y] = i+1;
        head[i] = {x,y};
    }
}

void advance(int i){
    while(1){
        int x2 = head[i].first + DX[dir[i]];
        int y2 = head[i].second + DY[dir[i]];
        if(!inbounds(x2,y2) || covered[x2][y2] != 0){
            dir[i] = (dir[i]+1)%4;
            break;
        }
        place(x2,y2,i);
    }
}

void solve(){
    place(n-1,0,0);
    place(0,0,1);
    place(0,m-1,2);
    advance(0);
    advance(1);
    advance(2);
    advance(2);
    advance(2);
    advance(2);
    bool turn = 0;
    while(cov < n*m){
        advance(int(turn)+1);
        turn ^= 1;
    }
    rep(c1,0,n){
        rep(c2,0,m){
            if(overlap[c1][c2]){
                rep(c3,0,4){
                    int x2 = c1+DX[c3];
                    int y2 = c2+DY[c3];
                    if(inbounds(x2,y2)){
                        ANS[c1][c2][covered[x2][y2]-1] = 1;
                    }
                }
            }
        }
    }
    print();
}

int main() {
    cin >> n >> m;
    rep(c1,0,n){
        string s;
        cin >> s;
        rep(c2,0,m){
            if(s[c2] == '2')overlap[c1][c2] = 1;
        }
    }
    if(n > m){
        swap(n,m);
        swapped = 1;
        rep(c1,0,n){
            rep(c2,0,m){
                if(c1 < c2)swap(overlap[c1][c2], overlap[c2][c1]);
            }
        }
    }
    if(n == 1){
        solve_1d();
    }
    else{
        solve();
    }
    return 0;
}