//#pragma GCC optimize("Ofast", "unroll-loops")
//#pragma GCC target("sse", "sse2", "sse3", "ssse3", "sse4")

#ifdef __APPLE__

#include <iostream>
#include <cmath>
#include <algorithm>
#include <stdio.h>
#include <cstdint>
#include <cstring>
#include <string>
#include <cstdlib>
#include <vector>
#include <bitset>
#include <map>
#include <queue>
#include <ctime>
#include <stack>
#include <set>
#include <list>
#include <random>
#include <deque>
#include <functional>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <complex>
#include <numeric>
#include <cassert>
#include <array>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <thread>

#else
#include <bits/stdc++.h>
#endif

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define mp make_pair
#define pb push_back
#define fir first
#define sec second
#define fi first
#define se second

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

template<typename T>
bool umin(T &a, T b) {
    if (b < a) {
        a = b;
        return true;
    }
    return false;
}

template<typename T>
bool umax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

#if __APPLE__
#define D for (bool _FLAG = true; _FLAG; _FLAG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl

template<class ...Ts>
auto &print(Ts ...ts) { return ((cerr << ts << " "), ...); }

#else
#define D while (false)
#define LOG(...)
#endif

const int max_n = -1, inf = 1000111222;

//mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

struct twosat {
    int n;
    vector<vector<int> > g, gt;
    vector<bool> u, assignment;
    vector<int> ord, comp;

    twosat(int _n = 0) {
        n = _n;
        g.resize(n * 2);
        gt.resize(n * 2);
    }

    int add_var() {
        g.emplace_back();
        gt.emplace_back();
        g.emplace_back();
        gt.emplace_back();
        return n++;
    }

    void dfs1(int v) {
        u[v] = 1;
        for (auto &x: g[v])
            if (!u[x])
                dfs1(x);
        ord.pb(v);
    }

    void dfs2(int v, int cl) {
        comp[v] = cl;
        for (auto &x: gt[v])
            if (comp[x] == -1)
                dfs2(x, cl);
    }

    bool solve2sat() {
        ord.clear();
        u.assign(n * 2, false);
        comp.assign(n * 2, -1);
        for (int i = 0; i < n * 2; i++)
            if (!u[i])
                dfs1(i);
        for (int i = 0, j = 0; i < n * 2; i++) {
            int cv = ord[n * 2 - i - 1];
            if (comp[cv] == -1)
                dfs2(cv, j++);
        }
        assignment.assign(n, false);
        for (int i = 0; i < n * 2; i += 2) {
            if (comp[i] == comp[i + 1]) return false;
            assignment[i / 2] = (comp[i] > comp[i + 1]);
        }
        return true;
    }

    void set_val(int x, bool nx) {
        either(x, nx, x, nx);
    }

    void either(int a, bool na, int b, bool nb) {
        a = ((2 * a) ^ na);
        b = ((2 * b) ^ nb);
        int neg_a = (a ^ 1);
        int neg_b = (b ^ 1);
        g[neg_a].push_back(b);
        g[neg_b].push_back(a);
        gt[b].push_back(neg_a);
        gt[a].push_back(neg_b);
    }

    void at_most_one(vector<pair<int, int> > cur) { //{variable, should be}
        for (int i = 0; i < cur.size(); i++) {
            int cvar = add_var();
            if (i > 0) either(cvar - 1, 0, cvar, 1);
            if (i > 0) either(cur[i - 1].fi, (cur[i - 1].se ^ 1), cvar, 1);
            either(cvar, 0, cur[i].fi, (cur[i].se ^ 1));
        }
    }

    void differs(int a, int b) {
        either(a, 0, b, 0);
        either(a, 1, b, 1);
    }

    void equals(int a, int b) {
        either(a, 0, b, 1);
        either(a, 1, b, 0);
    }
};

int N, M;

struct fedge {
    int v = 0, u = 0;
    ll cap = 0, flow = 0;
    fedge(int _v, int _u, ll _cap) : v(_v), u(_u), cap(_cap) {}
};
struct Dinic {
    const ll finf = 1e18 + 42;
    vector<fedge> edg;
    vector<vector<int> > g;
    int n = 0, m = 0, s = 0, t = 0;
    vector<int> lvl, ptr;
    queue<int> q;
    Dinic(int _n, int _s, int _t) {
        n = _n; s = _s; t = _t;
        g.resize(n + 1);
        lvl.resize(n + 1);
        ptr.resize(n + 1);
    }
    void add_edge(int v, int u, ll cap) {
        edg.pb(fedge(v, u, cap));
        edg.pb(fedge(u, v, 0));
        g[v].pb(m++);
        g[u].pb(m++);
    }
    char bfs() {
        while(!q.empty()) {
            int v = q.front(); q.pop();
            for(auto& x : g[v]) {
                if(edg[x].cap - edg[x].flow < 1 || lvl[edg[x].u] != -1) continue;
                lvl[edg[x].u] = lvl[v] + 1;
                q.push(edg[x].u);
            }
        }
        return (lvl[t] != -1);
    }
    ll dfs(int v, ll pushed) {
        if(pushed <= 0) return 0;
        if(v == t) return pushed;
        for(auto& x = ptr[v]; x < g[v].size(); x++) {
            int id = g[v][x];
            int to = edg[id].u;
            if(lvl[v] + 1 != lvl[to] || edg[id].cap - edg[id].flow < 1) continue;
            ll cr = dfs(to, min(pushed, edg[id].cap - edg[id].flow));
            if(!cr) continue;
            edg[id].flow += cr;
            edg[id ^ 1].flow -= cr;
            return cr;
        }
        return 0;
    }
    ll flow() {
        ll res = 0;
        while(true) {
            for(int i = 0; i <= n; i++) { lvl[i] = -1; ptr[i] = 0; }
            lvl[s] = 0;
            q.push(s);
            if(!bfs()) break;
            while(true) {
                ll cr = dfs(s, finf);
                if(!cr) break;
                else res += cr;
            }
        }
        return res;
    }
};

void solve() {
    int n, m;
    cin >> n >> m;
    N = 2 * n - 1, M = 2 * m - 1;
    vector<vector<char> > a(N, vector<char>(M));
    vector<vector<bool> > forced_off(N, vector<bool>(M));
    twosat kek(N * M);
    bool ok = true;
    vector<pair<int, int> > sevens1, sevens2;
    for(int i = 0; i < N; i++) {
        for(int j = 0; j < M; j++) {
            cin >> a[i][j];
            if(i % 2 == 0 && j % 2 == 0) {
                if(i == 0 && j == 0) {
                    if(a[i][j] == '3') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.set_val((i + 1) * M + j + 1, true);
                    kek.differs(i * M + j + 1, (i + 1) * M + j);
                } else if(i == 0 && j == M - 1) {
                    if(a[i][j] == '3') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.set_val((i + 1) * M + j - 1, true);
                    kek.differs(i * M + j - 1, (i + 1) * M + j);
                } else if(i == N - 1 && j == 0) {
                    if(a[i][j] == '3') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.set_val((i - 1) * M + j + 1, true);
                    kek.differs((i - 1) * M + j, i * M + j + 1);
                } else if(i == N - 1 && j == M - 1) {
                    if(a[i][j] == '3') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.set_val((i - 1) * M + j - 1, true);
                    kek.differs((i - 1) * M + j, i * M + j - 1);
                } else if(i == 0) {
                    if(a[i][j] == '5') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.differs(i * M + j - 1, i * M + j + 1);
                    for(int df = -1; df <= 1; df++) kek.set_val((i + 1) * M + j + df, true);
                } else if(i == N - 1) {
                    if(a[i][j] == '5') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.differs(i * M + j - 1, i * M + j + 1);
                    for(int df = -1; df <= 1; df++) kek.set_val((i - 1) * M + j + df, true);
                } else if(j == 0) {
                    if(a[i][j] == '5') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.differs((i - 1) * M + j, (i + 1) * M + j);
                    for(int df = -1; df <= 1; df++) kek.set_val((i + df) * M + j + 1, true);
                } else if(j == M - 1) {
                    if(a[i][j] == '5') {
                        for(int dx = -1; dx <= 1; dx++)
                            for(int dy = -1; dy <= 1; dy++)
                                if((i + dx) >= 0 && (i + dx) < N && (j + dy) >= 0 && (j + dy) < M)
                                    kek.set_val((i + dx) * M + j + dy, true);
                        continue;
                    }
                    kek.differs((i - 1) * M + j, (i + 1) * M + j);
                    for(int df = -1; df <= 1; df++) kek.set_val((i + df) * M + j - 1, true);
                } else {
                    if(a[i][j] == '7') {
                        if((i / 2 + j / 2) % 2) sevens1.pb({i, j});
                        else sevens2.pb({i, j});
                    }
                    for(int dx = -1; dx <= 1; dx++)
                        for(int dy = -1; dy <= 1; dy++)
                            if(!(dx == 0 && dy == 0)) {
                                kek.set_val((i + dx) * M + (j + dy), true);
                            }
                }
            }
        }
    }
    int s = len(sevens1) + len(sevens2), t = len(sevens1) + len(sevens2) + 1;
    Dinic dinic(len(sevens1) + len(sevens2) + 2, len(sevens1) + len(sevens2), len(sevens1) + len(sevens2) + 1);
    for(int i = 0; i < len(sevens1); i++) {
        dinic.add_edge(s, i, 1);
    }
    for(int i = 0; i < len(sevens2); i++) {
        dinic.add_edge(len(sevens1) + i, t, 1);
    }
    for(int i = 0; i < len(sevens1); i++)
        for(int j = 0; j < len(sevens2); j++) {
            int dx = abs(sevens1[i].fi - sevens2[j].fi), dy = abs(sevens1[i].se - sevens2[j].se);
            if((dx == 2 && dy == 0) || (dx == 0 && dy == 2)) dinic.add_edge(i, len(sevens1) + j, 1);
        }
    dinic.flow();
    int am_pairs = 0;
    for(int i = 0; i < dinic.edg.size(); i += 2)
        if(dinic.edg[i].v >= 0 && dinic.edg[i].v < len(sevens1) && dinic.edg[i].flow) {
            int A = dinic.edg[i].v, B = dinic.edg[i].u - len(sevens1);
            int x = (sevens1[A].fi + sevens2[B].fi) / 2, y = (sevens1[A].se + sevens2[B].se) / 2;
            forced_off[x][y] = true;
            am_pairs++;
        }
    if(ok && kek.solve2sat() && am_pairs * 2 == len(sevens1) + len(sevens2)) {
        cout << "YES\n";
        auto res = kek.assignment;
        for(int i = 0; i < N; i++) {
            for(int j = 0; j < M; j++) {
                if(i % 2 == 0 && j % 2 == 0) cout << a[i][j];
                else {
                    if(forced_off[i][j]) cout << '.';
                    else cout << (res[i * M + j] ? "." : "#");
                }
            }
            cout << '\n';
        }
    } else cout << "NO\n";
}

signed main() {
//   freopen("input.txt", "r", stdin);
//   freopen("output.txt", "w", stdout);

    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t = 1;

    //cin >> t;

    while (t--) solve();

}

/*
KIVI

4 5
3.5.5.5.3
.........
4.7.7.7.5
.........
4.7.8.8.5
.........
3.5.5.5.3
*/