#include <bits/stdc++.h>
using namespace std;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
using pii = pair<int, int>;
using i64 = long long;
#define rep(i, a, b) for (int i = a, I = b; i <= I; ++i)
#define per(i, a, b) for (int i = a, I = b; i >= I; --i)
template<typename T> void up(T &x, T y) { if (x < y) x = y; }
template<typename T> void down(T &x, T y) { if (x > y) x = y; }

const int N = 105, inf = 1e9;
const int dx[] = {1, -1, 0, 0, 1, -1, 1, -1}, dy[] = {0, 0, 1, -1, 1, 1, -1, -1};
int n, m, cnt[N][N], tp[N][N];
char s[N], res[N][N];

namespace flow {
	const int N = 14005, M = 123456;
	int n, s, t, d[N], que[N], cap[M], res;
	int cnt = 1, head[N], cur[N], to[M], nxt[M], val[M];

	void addedge(int u, int v, int w) {
		to[++cnt] = v;
        cap[cnt] = val[cnt] = w;
		nxt[cnt] = head[u];
		head[u] = cnt;
	}
	void add(int u, int v, int w) {
		addedge(u, v, w);
		addedge(v, u, 0); 
	}
	bool bfs() {
		int l = 1, r = 0;
		rep(i, 0, n) cur[i] = head[i], d[i] = 0;
		que[++r] = s, d[s] = 1;
		while (l <= r) {
			int u = que[l++];
			for (int i = head[u]; i; i = nxt[i]) {
				int v = to[i], w = val[i];
				if (d[v] || !w) continue;
				d[v] = d[u] + 1;
				que[++r] = v;
			}
		} 
		return d[t];
	}
	int dfs(int u, int flow) {
		if (u == t) return flow;
		int rest = flow;
		for (int &i = cur[u]; i; i = nxt[i]) {
			int v = to[i], w = val[i];
			if (d[v] != d[u] + 1 || !w) continue;
			int k = dfs(v, min(flow, w));
			if (!k) d[v] = 0;
			rest -= k;
			val[i] -= k, val[i ^ 1] += k; 
			if (!rest) break;
		}
		return flow - rest;
	}
	int dinic() {
		res = 0;
		while (bfs()) res += dfs(s, inf); 
		return res;
	}
    int find(int u) {
        for (int i = head[u]; i; i = nxt[i]) {
            int v = to[i];
            if (cap[i] && !val[i]) return v;
        }
        return -1;
    }
}

int ID(int x, int y) {
    return (x - 1) * m + y;
}

int main() {
    // freopen("1.in", "r", stdin);
    ios::sync_with_stdio(0), cin.tie(0);

    cin >> n >> m;
    flow::t = flow::n = n * m + 1;

    int sum = 0;
    rep(i, 1, n) {
        cin >> (s + 1);
        rep(j, 1, 2 * m - 1) {
            if (j % 2 == 0) s[j] = '#';
            res[i * 2 - 1][j] = s[j];
        }
        rep(j, 1, m) {
            int p = j * 2 - 1;
            cnt[i][j] = '0' - s[p];
            rep(d, 0, 7) {
                int x = i * 2 - 1 + dx[d], y = p + dy[d];
                if (x < 1 || x >= 2 * n || y < 1 || y >= 2 * m) continue;
                ++cnt[i][j], ++tp[i][j];
            }
            if (cnt[i][j]) {
                ++sum;
                assert(cnt[i][j] == 1);
                int u = ID(i, j);
                if ((i + j) & 1) {
                    flow::add(u, flow::t, 1);
                } else {
                    flow::add(flow::s, u, 1);
                }
            }
        }
        if (i < n) cin >> (s + 1);
        rep(j, 1, 2 * m - 1) res[i * 2][j] = '#';
    }

    rep(i, 1, n) rep(j, 1, m) {
        if ((i + j) & 1) continue;
        rep(d, 0, 3) {
            int x = i + dx[d], y = j + dy[d];
            if (x < 1 || x > n || y < 1 || y > m) continue;
            auto tmp = pii(tp[i][j], tp[x][y]);
            if (tp[i][j] > tp[x][y]) swap(tmp.first, tmp.second);
            if (tmp == pii(5, 8)) continue;
            if (tmp == pii(5, 5)) {
                if (m == 2 && y != j) continue;
                if (n == 2 && x != i) continue;
            }
            flow::add(ID(i, j), ID(x, y), 1);
        }
    }

    int max_f = flow::dinic();
    if (max_f * 2 < sum) {
        cout << "NO\n";
        exit(0);
    }
    assert(max_f == sum / 2);
    cout << "YES\n";
    rep(i, 1, n) rep(j, 1, m) {
        if ((i + j) & 1) continue;
        int u = ID(i, j), v = flow::find(u);
        if (v != -1) {
            rep(d, 0, 3) {
                int x = i + dx[d], y = j + dy[d];
                if (x < 1 || x > n || y < 1 || y > m) continue;
                int rv = ID(x, y);
                if (rv == v) {
                    res[x + i - 1][y + j - 1] = '.';
                }
            }
        }
    }

    rep(i, 1, 2 * n - 1) {
        rep(j, 1, 2 * m - 1) cout << res[i][j];
        cout << "\n";
    }

    return 0;
}