#include <bits/stdc++.h>
#define int long long

using namespace std;
 
using ull = uint64_t;
using ii = pair<int, int>;
using iii = pair<int, ii>;
// using i4 = tuple<int, int, int, int>;
using i4 = pair<ii, ii>;
using ll = long long;
 
const double eps = 1e-8;
const int inf = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9+7;
 
using ii = pair<int, int>;
using vi = vector<int>;
using iii = pair<int, ii>;

const int ms = 1e4, me = 1e5;

int adj[ms], to[me], ant[me], wt[me], z;
int copy_adj[ms], fila[ms], level[ms];
void clear() { // Lembrar de chamar no main
  memset(adj, -1, sizeof adj);
  z = 0;
}
void add(int u, int v, int k) {
  to[z] = v;
  ant[z] = adj[u];
  wt[z] = k;
  adj[u] = z++;
  swap(u, v);
  to[z] = v;
  ant[z] = adj[u];
  wt[z] = 0; // Lembrar de colocar = 0
  adj[u] = z++;
}
int bfs(int source, int sink) {
  memset(level, -1, sizeof level);
  level[source] = 0;
  int front = 0, size = 0, v;
  fila[size++] = source;
  while(front < size) {
    v = fila[front++];
    for(int i = adj[v]; i != -1; i = ant[i]) {
      if(wt[i] && level[to[i]] == -1) {
        level[to[i]] = level[v] + 1;
        fila[size++] = to[i];
      }
    }
  }
  return level[sink] != -1;
}
int dfs(int v, int sink, int flow) {
  if(v == sink) return flow;
  int f;
  for(int &i = copy_adj[v]; i != -1; i = ant[i]) {
    if(wt[i] && level[to[i]] == level[v] + 1 && 
      (f = dfs(to[i], sink, min(flow, wt[i])))) {
      wt[i] -= f;
      wt[i ^ 1] += f;
      return f;
    }
  }
  return 0;
}
int maxflow(int source, int sink) {
  int ret = 0, flow;
  while(bfs(source, sink)) {
    memcpy(copy_adj, adj, sizeof adj);
    while((flow = dfs(source, sink, 1 << 30))) {
      ret += flow;
    }
  }
  return ret;
}
int n, m;
int toIdx(int x, int y) {
  return x * m + y;
}
ii fromIdx(int id) {
  return {id / m, id % m};
}
bool isEdge(int x, int y) {
  return x == 0 || x == n - 1 || y == 0 || y == m - 1;
}
bool check(int x, int y) {
  return x >= 0 && x < n && y >= 0 && y < m;
}
void solve() {
  cin >> n >> m;
  vector<string> a(2*n - 1);
  for(int i = 0; i < 2*n - 1; ++i) {
    cin >> a[i];
  }
  vector<vector<int>> grid(n, vector<int>(m, 0));
  for(int i = 0; i < 2*n - 1; i += 2) {
    for(int j = 0; j < 2*m - 1; j+= 2) {
      grid[i / 2][j / 2] = a[i][j] - '0';
    }
  }
  int src = ms - 3, snk = ms - 2;
  for(int i = 0; i < n; i++) {
    for(int j = (i & 1); j < m; j += 2) {
      for(int dx : {1, -1, 0}) {
        for(int dy : {1, -1, 0}) {
          if(abs(dx + dy) != 1) continue;
          int nx = i + dx, ny = j + dy;
          if(!check(nx, ny) || (isEdge(i, j) != isEdge(nx, ny))) continue;
          if(n == 2 && i != nx && j != 0 && j != m - 1) continue;
          if(m == 2 && j != ny && i != 0 && i != n - 1) continue;
          // cout << i << ' ' << j << " -> " << nx << ' ' << ny << endl;
          add(toIdx(i, j), toIdx(nx, ny), 1);
        }
      }
    }
  }
  int need = 0;
  for(int i = 0; i < n; ++i) {
    for(int j = 0; j < m; ++j) {
      if(grid[i][j] == 2 || grid[i][j] == 4 || grid[i][j] == 7) {
        need++;
        if((i + j) % 2) {
          add(toIdx(i, j), snk, 1);
        } else {
          add(src, toIdx(i, j), 1);
        }
      }
    }
  }
  int ans = maxflow(src, snk);
  if(need % 2 || ans != need / 2) {
    cout << "NO\n";
    return;
  }
  cout << "YES\n";
  for(int i = 0; i < 2*n - 1; ++i) {
    for(int j = 0; j < (int) a[i].size(); ++j) {
      if(a[i][j] == '.') a[i][j] = '#';
    }
  }
  for(int i = 0; i < z; i += 2) {
    if(to[i] != snk && to[i^1] != src && wt[i^1] != 0) {
      ii f = fromIdx(to[i]);
      ii s = fromIdx(to[i^1]);
      for(int dx : {1, -1, 0}) {
        for(int dy : {1, -1, 0}) {
          if(abs(dx + dy) != 1) continue;
          int nx = f.first + dx, ny = f.second + dy;
          if(make_pair(nx, ny) != s) continue;
          a[f.first * 2 + dx][f.second * 2 + dy] = '.';
        }
      }
    }
  }
  for(int i = 0; i < 2 * n - 1; ++i) {
    cout << a[i] << '\n';
  }
}
 
int32_t main() {
  // #ifdef ONLINE_JUDGE
  //   freopen("milk.in", "r", stdin);
  // #endif
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  cout << fixed << setprecision(11);
  int t = 1;
  clear();
  // cin >> t;
  for(int T = 1; T <= t; T++) {
    solve(); 
  }
  return 0;
}