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

using i64 = long long;

struct BipartiteMatching {
    int n, m;
    vector<vector<int>> adj;
    vector<int> l, r, dis, cur;
    BipartiteMatching(int n, int m) : n(n), m(m), adj(n), l(n, -1), r(m, -1), dis(n), cur(n) {}
    void addEdge(int u, int v) { adj[u].push_back(v); }
    void bfs() {
        vector<int> q;
        for (int u = 0; u < n; u++) {
            if (l[u] == -1) {
                q.push_back(u), dis[u] = 0;
            } else {
                dis[u] = -1;
            }
        }
        for (int i = 0; i < int(q.size()); i++) {
            int u = q[i];
            for (auto v : adj[u]) {
                if (r[v] != -1 && dis[r[v]] == -1) {
                    dis[r[v]] = dis[u] + 1;
                    q.push_back(r[v]);
                }
            }
        }
    }
    bool dfs(int u) {
        for (int &i = cur[u]; i < int(adj[u].size()); i++) {
            int v = adj[u][i];
            if (r[v] == -1 || dis[r[v]] == dis[u] + 1 && dfs(r[v])) {
                l[u] = v, r[v] = u;
                return true;
            }
        }
        return false;
    }
    int maxMatching() {
        int match = 0;
        while (true) {
            bfs();
            fill(cur.begin(), cur.end(), 0);
            int cnt = 0;
            for (int u = 0; u < n; u++) {
                if (l[u] == -1) {
                    cnt += dfs(u);
                }
            }
            if (cnt == 0) {
                break;
            }
            match += cnt;
        }
        return match;
    }
    auto minVertexCover() {
        vector<int> L, R;
        for (int u = 0; u < n; u++) {
            if (dis[u] == -1) {
                L.push_back(u);
            } else if (l[u] != -1) {
                R.push_back(l[u]);
            }
        }
        return pair(L, R);
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    
    auto solve = [&]() {
        int n, m;
        cin >> n >> m;

        vector<string> a(2 * n - 1);
        for (int i = 0; i < 2 * n - 1; i++) {
            cin >> a[i];
            for (int j = 0; j < 2 * m - 1; j++) {
                if (a[i][j] == '.') {
                    a[i][j] = '#';
                }
            }
        }

        auto bad = [&](char x) {
            return x == '2' || x == '4' || x == '7';
        };

        vector id(2 * n - 1, vector<int>(2 * m - 1, -1));
        vector pos(2, vector<pair<int, int>>());

        for (int i = 0; i < 2 * n - 1; i += 2) {
            for (int j = 0; j < 2 * m - 1; j += 2) {
                int p = (i + j) % 4 / 2;
                if (bad(a[i][j])) {
                    id[i][j] = pos[p].size();
                    pos[p].emplace_back(i, j);
                }
            }
        }


        int N = pos[0].size();
        if (N != int(pos[1].size())) {
            cout << "NO\n";
            return;
        }

        BipartiteMatching bm(N, N);

        auto connect = [&](int i, int j, int ni, int nj) {
            if (a[i][j] % 2 != a[ni][nj] % 2) {
                return false;
            }
            if (n == 2 && abs(i - ni) == 2 && a[i][j] == '4') {
                return false;
            }
            if (m == 2 && abs(j - nj) == 2 && a[i][j] == '4') {
                return false;
            }
            return true;
        };

        for (int i = 0; i < 2 * n - 1; i += 2) {
            for (int j = 0; j < 2 * m - 1; j += 2) {
                if ((i + j) % 4 != 0 || id[i][j] == -1) {
                    continue;
                }

                for (auto [di, dj] : {pair{2, 0}, {0, 2}, {-2, 0}, {0, -2}}) {
                    int ni = i + di, nj = j + dj;
                    if (0 <= ni && ni < 2 * n - 1 && 0 <= nj && nj < 2 * m - 1 && id[ni][nj] != -1 && connect(i, j, ni, nj)) {
                        bm.addEdge(id[i][j], id[ni][nj]);
                    }
                }
            }
        }

        if (bm.maxMatching() != N) {
            cout << "NO\n";
            return;
        }

        cout << "YES\n";

        for (int i = 0; i < N; i++) {
            auto [x, y] = pos[0][i];
            auto [nx, ny] = pos[1][bm.l[i]];
            a[(x + nx) / 2][(y + ny) / 2] = '.';
        }

        for (int i = 0; i < 2 * n - 1; i++) {
            cout << a[i] << '\n';
        }
    };

    solve();

    return 0;
}