#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#ifdef APURBA
#include "DEBUG_TEMPLATE.h"
#else
#define HERE
#define debug(args...)
#endif
#define ALL(x) x.begin(),x.end()

const int N = 105 +5;
typedef pair<int,int> pii;


const long long flow_inf = 1e18;
struct FlowEdge {
  int v,u,id; long long cap, flow = 0;
  FlowEdge(int v, int u, long long cap,int id=-1) : v(v), u(u), cap(cap),id(id) {}
};
struct Dinic
{
  vector<FlowEdge> edges; vector<vector<int> > adj;
  int n, m = 0; int s, t;
  vector<int> level, ptr,flow_through;
  queue<int> q; vector<bool>vis;
  int maxid=0;
  Dinic() {}
  Dinic(int n) : n(n) {
    vis.resize(n); adj.resize(n);
    level.resize(n); ptr.resize(n);
  }
  void add_edge(int v, int u, long long cap,int id=-1) {
    edges.emplace_back(v, u, cap,id);
    edges.emplace_back(u, v, 0);
    adj[v].push_back(m);
    adj[u].push_back(m + 1);
    m += 2;
    if(id!=-1)maxid++;
  }
  void dfs2(int s) {
    vis[s] = 1;
    for(int i:adj[s]) {
      int id = i; int u = edges[id].v;
      int v = edges[id].u;
      if(edges[id].flow!=edges[id].cap && !vis[v])
      {
        dfs2(v);
      }
    }
  }
  vector<int> getMinCut() {
    dfs2(s); vector<int>ret;
    for(int i=0; i<n; i++) {
      if(vis[i]) ret.push_back(i);
    }
    return ret;
  }
  bool bfs() {
    while (!q.empty()) {
      int v = q.front();
      q.pop();
      for (int id : adj[v])
      {
        if (edges[id].cap - edges[id].flow < 1)
          continue;
        if (level[edges[id].u] != -1)
          continue;
        level[edges[id].u] = level[v] + 1;
        q.push(edges[id].u);
      }
    }
    return level[t] != -1;
  }
  long long dfs(int v, long long pushed) {
    if (pushed == 0) return 0;
    if (v == t) return pushed;
    for (int& cid = ptr[v]; cid < (int)adj[v].size(); cid++){
      int id = adj[v][cid]; int u = edges[id].u;
      if (level[v] + 1 != level[u] || edges[id].cap - edges[id].flow < 1)
        continue;
      long long tr = dfs(u, min(pushed, edges[id].cap - edges[id].flow));
      if (tr == 0)
        continue;
      edges[id].flow += tr; edges[id ^ 1].flow -= tr;
      return tr;
    }
    return 0;
  }
  long long flow(int _s,int _t) {
    s=_s; t=_t;
    long long f = 0;
    while (true)
    {
      fill(level.begin(), level.end(), -1);
      level[s] = 0; q.push(s);
      if (!bfs()) break;
      fill(ptr.begin(), ptr.end(), 0);
      while (long long pushed = dfs(s, flow_inf)){
        f += pushed;
      }
    }
    flow_through.assign(maxid+1, 0);
    for(int i = 0; i < n; i++){
      for(auto j : adj[i]) {
        int idx = j;
        FlowEdge e = edges[idx];
        if(e.id >= 0)flow_through[e.id] = e.flow;
      }
    }
    return f;
  }
};


string s[N];
int to[N][N];
int idx[N][N];
int mx[N][N];
void TEST_CASES()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n*2-1;i++)
        cin>>s[i];

    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            int ii=2*i;
            int jj=2*j;
            int tot = 0 ;
            tot+=0<i and i<n-1;
            tot+=0<j and j<m-1;
            int now = 3;
            if(tot)
            {
                now+=2;
                tot--;
            }
            if(tot)
            {
                now+=3;
            }
            int ase = s[ii][jj]-'0';
            to[i][j] = ase!=now;
            mx[i][j] = now;
            assert(ase<=now and abs(ase-now)<=1);
            debug(i,j,to[i][j],now);
        }
    }
    int total = 0;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(to[i][j] and (i+j)%2 == 0)
            {
                idx[i][j] = total++;
            }
        }
    }
    int lft = total;
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            if(to[i][j] and (i+j)%2 == 1)
            {
                idx[i][j] = total++;
            }
        }
    }
    int rht = total;
    int src = total++;
    int snk  = total++;
    Dinic f(total);
    vector<array<int,2> > vs;
    auto ok = [&](int i,int j)
    {
        if(i>j) swap(i,j);
        if(i==5 and j==8)
            return 0;
        return 1;
    };
    for(auto i:{0,n-1})
    {
        for(int j=0;j+1<m;j++)
        {
            int ii=2*i;
            int jj=2*j;
            int jjj=jj+2;
            if(to[i][j] and to[i][j+1] and ok(mx[i][j],mx[i][j+1]))
            {
                int x = idx[i][j];
                int y = idx[i][j+1];
                if(x>y) swap(x,y);
                f.add_edge(x,y,1,vs.size());
                vs.push_back({ii,jj+1});
            }
        }
    }
    for(int i=1;i<n-1;i++)
    {
        for(int j=1;j+2<m;j++)
        {
            int ii=2*i;
            int jj=2*j;
            int jjj=jj+2;
            if(to[i][j] and to[i][j+1] and ok(mx[i][j],mx[i][j+1]))
            {
                int x = idx[i][j];
                int y = idx[i][j+1];
                if(x>y) swap(x,y);
                f.add_edge(x,y,1,vs.size());
                vs.push_back({ii,jj+1});
            }
        }
    }
    for(int i=1;i+2<n;i++)
    {
        for(int j=1;j+1<m;j++)
        {
            int ii=2*i;
            int jj=2*j;
            int iii=ii+2;
            if(to[i][j] and to[i+1][j] and ok(mx[i][j],mx[i+1][j]))
            {
                int x = idx[i][j];
                int y = idx[i+1][j];
                if(x>y) swap(x,y);
                f.add_edge(x,y,1,vs.size());
                vs.push_back({ii+1,jj});
            }
        }
    }
    for(int i=0;i+1<n;i++)
    {
        for(auto j:{0,m-1})
        {
            int ii=2*i;
            int jj=2*j;
            int iii=ii+2;
            if(to[i][j] and to[i+1][j] and ok(mx[i][j],mx[i+1][j]))
            {
                int x = idx[i][j];
                int y = idx[i+1][j];
                if(x>y) swap(x,y);
                f.add_edge(x,y,1,vs.size());
                vs.push_back({ii+1,jj});
            }
        }
    }
    for(int i=0;i<lft;i++)
        f.add_edge(src,i,1);
    for(int i=lft;i<rht;i++)
        f.add_edge(i,snk,1);

    int x = f.flow(src,snk);
    if(x*2!=rht)
    {
        cout<<"NO\n";
        return ;
    }
    cout<<"YES\n";
    for(int i=0;i<2*n-1;i++)
    {
        for(int j=0;j<2*m-1;j++)
            if(s[i][j]=='.')
                s[i][j]='#';
    }
    for(int i=0;i<vs.size();i++)
    {

        if(f.flow_through[i] == 1)
        {
            auto [x,y] = vs[i];
            s[x][y]='.';
        }
    }
    for(int i=0;i<n;i++)
    {
        for(int j=0;j<m;j++)
        {
            int ii=i*2;
            int jj=j*2;
            int tot = 0;
            for(int di=-1;di<=1;di++)
            {
                for(auto dj : {-1,0,1})
                    {
                        if(di==0 and dj==0) continue;
                        int iii=ii+di;
                        int jjj=jj+dj;
                        if(iii<0 or iii>=2*n-1) continue;
                        if(jjj<0 or jjj>=2*m-1) continue;
                        tot+=s[iii][jjj]=='#';
                    }
            }
            assert(s[ii][jj] -'0' == tot);
        }
    }
    for(int i=0;i<2*n-1;i++)
        cout<<s[i]<<"\n";

}




/*
3 3
3.4.3
.....
5.7.5
.....
3.5.3
*/

int32_t main()
{
#ifndef APURBA
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#endif
    //freopen("input.txt","r",stdin);
    //freopen("out1.txt","w",stdout);
    int t=1;
    //cin>>t;
    while(t--)
    {
        TEST_CASES();
    }
    return 0;
}