#include <bits/stdc++.h>

using namespace std;

const int INF = 0x3f3f3f3f;

namespace Dinic{
    static const int maxv = 1e5, maxe = 1e6;
    int tot, hd, tl;
    int head[maxv], level[maxv], iter[maxv], que[maxv];
    int to[maxe], cap[maxe], nxt[maxe];
    inline void init(){
        // puts("init");
        tot = 0;
        memset(head, -1, sizeof(head));
        return;
    }
    inline void add(int u, int v, int w){
        // puts("ok");
        to[tot] = v, cap[tot] = w, nxt[tot] = head[u];
        head[u] = tot++; return;
    }
    inline int addEdge(int u, int v, int w){ /*puts("ok");*/ int ret = tot; add(u, v, w), add(v, u, 0); return ret; }
    inline void bfs(int s){
        memset(level, -1, sizeof(level));
        hd = tl = 0;
        que[tl++] = s, level[s] = 0;
        for(; hd < tl; ){
            int u = que[hd++];
            // printf("u = %d head = %d\n", u, head[u]);
            for(int i = head[u]; ~i; i = nxt[i]){
                // printf("i = %d\n", i);
                int v = to[i];
                if(cap[i] && !~level[v]){
                    level[v] = level[u] + 1;
                    que[tl++] = v;
                }
            }
        }
        return;
    }
    inline int dfs(int u, int t, int f){
        if(u == t) return f;
        for(int &i = iter[u]; ~i; i = nxt[i]){
            int v = to[i];
            if(cap[i] && level[v] > level[u]){
                int d = dfs(v, t, min(cap[i], f));
                if(d){
                    cap[i] -= d, cap[i ^ 1] += d;
                    return d;
                }
            }
        }
        return 0;
    }
    inline int maxFlow(int s, int t){
        int ret = 0;
        while(true){
            memcpy(iter, head, sizeof(head));
            bfs(s);
            if(!~level[t]) break;
            for(int f; f = dfs(s, t, INF); ret += f);
        }
        return ret;
    }
}

const int maxn = 105;

int n, m;
int ans[maxn][maxn], f[maxn][maxn], id[maxn][maxn];
char buf[maxn][maxn];

inline void RET(){ puts("NO"); exit(0); }

inline bool check5(char c, int &x0, int &x1, int &x2, int &x3, int &x4){
    if(c == '5'){
        if(x0 == 0 || x1 == 0) return false;
        x0 = x1 = x2 = x3 = x4 = 1;
    }
    else{
        if(x0 == 0 || x1 == 0) x2 = x3 = x4 = 1;
        else x2 = x3 = 1, x4 = 0;
    }
    return true;
}

inline bool check3(char c, int &x0, int &x1, int &x2){
    if(c == '3'){
        if(x0 == 0 || x1 == 0) return false;
        x0 = x1 = x2 = 1;
    }
    else{
        if(x0 == 0 || x1 == 0) x2 = 1;
        else x2 = 0;
    }
    return true;
}

inline bool check(){
    for(int i = 1; i < m - 1; ++i){
        if(!check5(buf[0][i * 2], ans[0][i * 2 - 1], ans[1][i * 2 - 1], 
            ans[1][i * 2], ans[1][i * 2 + 1], ans[0][i * 2 + 1])) return false;
    }
    if(!check3(buf[0][m * 2 - 2], ans[0][m * 2 - 3], ans[1][m * 2 - 3], ans[1][m * 2 - 2]))
        return false;
    for(int i = 1; i < n - 1; ++i){
        if(!check5(buf[i * 2][m * 2 - 2], ans[i * 2 - 1][m * 2 - 2], ans[i * 2 - 1][m * 2 - 3],
            ans[i * 2][m * 2 - 3], ans[i * 2 + 1][m * 2 - 3], ans[i * 2 + 1][m * 2 - 2])) return false;
    }
    if(!check3(buf[n * 2 - 2][m * 2 - 2], ans[n * 2 - 3][m * 2 - 2], ans[n * 2 - 3][m * 2 - 3], ans[n * 2 - 2][m * 2 - 3]))
        return false;
    for(int i = m - 2; i >= 1; --i){
        if(!check5(buf[n * 2 - 2][i * 2], ans[n * 2 - 2][i * 2 + 1], ans[n * 2 - 3][i * 2 + 1],
            ans[n * 2 - 3][i * 2], ans[n * 2 - 3][i * 2 - 1], ans[n * 2 - 2][i * 2 - 1])) return false;
    }
    if(!check3(buf[n * 2 - 2][0], ans[n * 2 - 2][1], ans[n * 2 - 3][1], ans[n * 2 - 3][0]))
        return false;
    for(int i = n - 2; i >= 1; --i){
        if(!check5(buf[i * 2][0], ans[i * 2 + 1][0], ans[i * 2 + 1][1],
            ans[i * 2][1], ans[i * 2 - 1][1], ans[i * 2 - 1][0])) return false;
    }

    // fuck
    if((ans[0][1] + ans[1][1] + ans[1][0]) != (buf[0][0] - '0')) return false;
    return true;
}

inline void solve1(){
    for(int i = 0; i < n * 2 - 1; ++i) for(int j = 0; j < m * 2 - 1; ++j) ans[i][j] = 1;
    ans[1][1] = 1;
    if(buf[0][0] == '3'){
        ans[0][1] = ans[1][0] = 1;
        if(!check()) RET();
    }
    else{
        ans[0][1] = 1, ans[1][0] = 0;
        if(check()) return;
        ans[0][1] = 0, ans[1][0] = 1;
        if(check()) return;
        RET();
    }
}

int main(){
    scanf("%d%d", &n, &m);
    for(int i = 0; i < (n * 2 - 1); ++i){
        scanf("%s", buf[i]);
    }

    solve1();
    /*
    for(int i = 0; i < n * 2 - 1; ++i){
        for(int j = 0; j < m * 2 - 1; ++j) printf("%d ", ans[i][j]); puts("");
    }
    */
    Dinic::init();
    int tot = 0;
    int S = ++tot, T = ++tot, cnt = 0;
    for(int i = 1; i < n - 1; ++i){
        for(int j = 1; j < m - 1; ++j){
            if(buf[i * 2][j * 2] == '7'){
                id[i][j] = ++tot;
                ++cnt;
                if((i + j) & 1) Dinic::addEdge(S, id[i][j], 1);
                else Dinic::addEdge(id[i][j], T, 1);
            }
        }
    }

    const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};

    memset(f, -1, sizeof(f));
    for(int i = 1; i < n - 1; ++i){
        for(int j = 1; j < m - 1; ++j) if((i + j) & 1){
            for(int k = 0; k < 4; ++k){
                int x = i + dx[k], y = j + dy[k];
                if(x >= 1 && x < n - 1 && y >= 1 && y < m - 1 && buf[x * 2][y * 2] == '7'){
                    f[i * 2 + dx[k]][j * 2 + dy[k]] = Dinic::addEdge(id[i][j], id[x][y], 1);
                }
            }
        }
    }

    if(Dinic::maxFlow(S, T) * 2 != cnt) RET();

    puts("YES");
    for(int i = 0; i < n * 2 - 1; ++i){
        for(int j = 0; j < m * 2 - 1; ++j){
            if(isdigit(buf[i][j])) putchar(buf[i][j]);
            else{
                if(~f[i][j]) ans[i][j] = (Dinic::cap[f[i][j]] == 0 ? 0 : 1);
                putchar(ans[i][j] ? '#' : '.');
            }
        }
        puts("");
    }
    return 0;
}