#include <bits/stdc++.h>

using namespace std;
#define int long long
#define endl '\n'
#define eb emplace_back
#define INF (int)(1e18)
#define pii pair<int, int> 
#define dbg(x...) do{cout<<#x<<" -> ";err(x);}while (0)
void err(){cout<<'\n';cout.flush();}
template<class T, class... Ts>
void err(T arg, Ts... args) {
    cout<<arg<< ' ';
    err(args...);
}

const int N = 1e4 + 10;
struct Dinic {
    struct v_e {
        int to;
        int cap;
        int flow;
        int rev;
        int realFlag;
        pii pos;
    };
    void addEdge(int u, int v, int cap, pii pos) {
        g[u].eb((v_e){v, cap, 0, g[v].size(), 1, pos});
        g[v].eb((v_e){u, 0, 0, g[u].size() - 1, 0, pos});
    }
    int bfs() {
        memset(lv, 0, sizeof lv);
        memset(cur, 0, sizeof cur);
        queue<int> q;
        q.push(S);
        lv[S] = 1;
        while (!q.empty()) {
            int now = q.front();
            q.pop();
            for (auto x : g[now]) {
                if (x.cap - x.flow > 0 && lv[x.to] == 0) {
                    lv[x.to] = lv[now] + 1;
                    q.push(x.to);
                }
            }
        }
        return lv[T];
    }

    int dfs(int now, int mx) {
        if (now == T) return mx;
        int use = 0;
        for (int &i = cur[now]; i < g[now].size(); i++) {
            auto &x = g[now][i];
            if (x.cap - x.flow > 0 && lv[x.to] == lv[now] + 1) {
                int f = dfs(x.to, min(mx - use, x.cap - x.flow));
                use += f;
                x.flow += f;
                g[x.to][x.rev].flow -= f;
                if (f == 0) lv[x.to] = -1;
                if (use == mx) break;
            }
        }
        return use;
    }

    int dinic() {
        int ret = 0;
        while (bfs()) {
            ret += dfs(S, INF);
        }
        return ret;
    }

    int S, T;
    vector<v_e> g[N];
    int lv[N];
    int cur[N];
} dnk;

int n, m;
char crr[110][110];
int arr[110][110];
inline int id(int r, int c) {
    return (r - 1) * m + c;
}
inline int id(pii p) {
    return (p.first - 1) * m + p.second;
}
inline bool check(pii p) {
    int r = p.first, c = p.second;
    return ((r + 1) / 2 + (c + 1) / 2) & 1;
}
pii mid(pii a, pii b) {
    return pii(a.first + b.first >> 1, a.second + b.second >> 1);
}
void run() {
    cin >> n >> m;
    n = n * 2 - 1;
    m = m * 2 - 1;
    int cnt = 0;
    for (int i = 1; i <= n; i++) {
        string str;
        cin >> str;
        for (int j = 1; j <= m; j++) {
            crr[i][j] = str[j - 1];
            if (crr[i][j] == '.') crr[i][j] = '#';
            else {
                arr[i][j] = crr[i][j] - '0';
                if (arr[i][j] == 2 || arr[i][j] == 4 || arr[i][j] == 7) cnt++;
            }
        }
    }
    if (cnt & 1) return (void)(cout << "NO" << endl);

    int dr[4] = {2, 0, -2, 0}, dc[4] = {0, 2, 0, -2}, dl[2] = {2, -2};
    vector<int> ln, cl;
    ln.eb(1);
    ln.eb(n);
    cl.eb(1);
    cl.eb(m);
    for (auto r : ln) {
        for (int j = 1; j <= m; j += 2) {
            pii now = pii(r, j);
            if (check(now)) {
                for (int k = 0; k < 2; k++) {
                    pii nx = pii(now.first, now.second + dl[k]);
                    if (nx.second <= 0 || nx.second > m) continue;
                    pii jud = pii(arr[now.first][now.second], arr[nx.first][nx.second]);
                    if (jud == pii(2, 4) || jud == pii(4, 4) || jud == pii(4, 2) || jud == pii(2, 2)) {
                        dnk.addEdge(id(now), id(nx), 1, mid(now, nx));
                    }
                }
            }
        }
    }
    for (auto c : cl) {
        for (int i = 1; i <= n; i += 2) {
            pii now = pii(i, c);
            if (check(now)) {
                for (int k = 0; k < 2; k++) {
                    pii nx = pii(now.first + dl[k], now.second);
                    if (nx.first <= 0 || nx.first > n) continue;
                    pii jud = pii(arr[now.first][now.second], arr[nx.first][nx.second]);
                    if (jud == pii(2, 4) || jud == pii(4, 4) || jud == pii(4, 2) || jud == pii(2, 2)) {
                        dnk.addEdge(id(now), id(nx), 1, mid(now, nx));
                    }
                }
            }
        }
    }

    for (int i = 3; i <= n - 2; i += 2) {
        for (int j = 3; j <= m - 2; j += 2) {
            pii now = pii(i, j);
            if (check(now)) {
                for (int k = 0; k < 4; k++) {
                    pii nx = pii(now.first + dr[k], now.second + dc[k]);
                    if (nx.first <= 1 || nx.first >= n || nx.second <= 1 || nx.second >= m) continue;
                    pii jud = pii(arr[now.first][now.second], arr[nx.first][nx.second]);
                    if (jud == pii(7, 7)) {
                        dnk.addEdge(id(now), id(nx), 1, mid(now, nx));
                    }
                }
            }
        }
    }

    dnk.S = n * m + 1, dnk.T = n * m + 2;
    for (int i = 1; i <= n; i += 2) {
        for (int j = 1; j <= m; j += 2) {
            if (check(pii(i, j))) {
                dnk.addEdge(dnk.S, id(i, j), 1, pii(-INF, -INF));
            } else {
                dnk.addEdge(id(i, j), dnk.T, 1, pii(-INF, -INF));
            }
        }
    }

    if (dnk.dinic() != cnt / 2) return (void)(cout << "NO" << endl);
    else cout << "YES" << endl;

    for (int i = 1; i <= n * m; i++) {
        for (auto x : dnk.g[i]) {
            if (x.realFlag && x.flow && x.pos.first != -INF) {
                crr[x.pos.first][x.pos.second] = '.';
            }
        }
    }

    for (int i = 1; i <= n; i++) { 
        for(int j = 1; j <= m; j++) {
            cout << crr[i][j];
        }
        cout << endl;
    }



    return;
}
signed main() {
    ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
    int T = 1;
    // cin >> T;
    while (T--) {
        run();
    }


    return 0;
}