//
// Stvoreno mustangom288 o 20.07.2023 08:36:54
//

#include <bits/stdc++.h>

#define F first
#define S second
#define MP make_pair
#define PB push_back

#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

using namespace std;

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

#ifdef Energy_is_not_over
#define DEBUG for (bool ____DEBUG = true; ____DEBUG; ____DEBUG = false)
#define LOG(...) print(#__VA_ARGS__" ::", __VA_ARGS__) << endl

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

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

const int max_n = 110, inf = 1000111222;

int n, m;
char f[max_n][max_n];
char ans[max_n][max_n];
int ind[max_n][max_n];

int di[]= {-1, -1, -1, 0, 0, 1, 1, 1};
int dj[] = {-1, 0, 1, -1, 1, -1, 0, 1};

template<typename Edge>
class GraphIterator {
public:
    class OutgoingEdges {
    public:
        OutgoingEdges(const GraphIterator *g, int l, int r): g(g), l(l), r(r) {
        }

        const Edge* begin() const {
            if (l == r) {
                return 0;
            }
            return &g->prepared_edges[l];
        }

        const Edge* end() const {
            if (l == r) {
                return 0;
            }
            return &g->prepared_edges[r];
        }

    private:
        int l, r;
        const GraphIterator *g;
    };

    void clear() {
        prepared_edges.clear();
        edges.clear();
        start.clear();
        prepared = false;
    }

    void add_edge(int from, const Edge &e) {
        assert(!prepared && from >= 0);
        edges.push_back({from, e});
    }

    void prepare() {
        assert(!prepared);
        int n = 0;
        for (const auto &e : edges) {
            n = max(n, e.first);
        }
        n += 2;
        start.resize(n);
        for (const auto &e : edges) {
            ++start[e.first + 1];
        }
        for (int i = 1; i < n; ++i) {
            start[i] += start[i - 1];
        }
        prepared_edges.resize(edges.size() + 1);
        auto counter = start;
        for (const auto &e : edges) {
            prepared_edges[counter[e.first]++] = e.second;
        }
        prepared = true;
    }

    OutgoingEdges operator [] (int from) const {
        assert(prepared);
        if (from < 0 || from + 1 >= start.size()) {
            return {this, 0, 0};
        }
        return {this, start[from], start[from + 1]};
    }

private:
    vector<Edge> prepared_edges;
    vector<pair<int, Edge>> edges;
    vector<int> start;
    bool prepared = false;
};

class Solver {
public:
    Solver(int n, const vector<pair<int, int>> &edges): n(n), sides(n, -1), p(n, -1)  {
        for (const auto [u, v] : edges) {
            assert(0 <= u && u < n);
            assert(0 <= v && v < n);
            g.add_edge(u, v);
            g.add_edge(v, u);
        }
        g.prepare();
        fill_sides();
        find_maximum_matching();
    }

    Solver(int n1, int n2, const vector<pair<int, int>> &edges): n(n1 + n2), sides(n1 + n2, 0), p(n1 + n2, -1)  {
        assert(0 <= n1 && 0 <= n2);
        for (const auto [u, v] : edges) {
            assert(0 <= u && u < n1);
            assert(n1 <= v && v < n1 + n2);
            g.add_edge(u, v);
        }
        g.prepare();
        fill(sides.begin(), sides.begin() + n1, 1);
        find_maximum_matching();
    }

    vector<pair<int, int>> maximum_matching() const {
        vector<pair<int, int>> result;
        for (int i = 0; i < n; ++i) {
            if (i < p[i]) {
                result.push_back({i, p[i]});
            }
        }
        return result;
    }

    vector<int> minimum_vertex_cover() const {
        vector<char> visited(n);
        function<void(int)> dfs = [&](int v) {
            if (visited[v]) {
                return;
            }
            visited[v] = true;
            if (sides[v]) {
                for (int to : g[v]) {
                    dfs(to);
                }
            } else {
                dfs(p[v]);
            }
        };
        for (int i = 0; i < n; ++i) {
            if (!visited[i] && sides[i] && p[i] == -1) {
                dfs(i);
            }
        }
        vector<int> result;
        for (int i = 0; i < n; ++i) {
            if (sides[i] != visited[i]) {
                result.push_back(i);
            }
        }
        return result;
    }

    vector<int> maximum_independent_set() const {
        vector<int> mvc = minimum_vertex_cover();
        mvc.insert(mvc.begin(), -1);
        mvc.push_back(n);
        vector<int> result;
        for (int i = 0; i + 1 < mvc.size(); ++i) {
            for (int v = mvc[i] + 1; v < mvc[i + 1]; ++v) {
                result.push_back(v);
            }
        }
        return result;
    }

    vector<pair<int, int>> minimum_edge_cover() const {
        vector<int> any_neighbor(n, -1);
        for (int i = 0; i < n; ++i) {
            for (int to : g[i]) {
                any_neighbor[i] = to;
                any_neighbor[to] = i;
            }
        }
        vector<pair<int, int>> result;
        for (int i = 0; i < n; ++i) {
            if (p[i] == -1) {
                assert(any_neighbor[i] != -1 && "some vertex is not covered by any edge");
                result.push_back({min(i, any_neighbor[i]),
                                  max(i, any_neighbor[i])});
            } else if (i < p[i]) {
                result.push_back({i, p[i]});
            }
        }
        return result;
    }

private:
    void fill_sides() {
        function<void(int, int)> fill_sides_dfs = [&](int v, int color) {
            sides[v] = color;
            for (int to : g[v]) {
                if (sides[to] == -1) {
                    fill_sides_dfs(to, color ^ 1);
                } else if (sides[to] != (sides[v] ^ 1)) {
                    assert(false && "graph is not bipartite");
                }
            }
        };
        for (int i = 0; i < n; ++i) {
            if (sides[i] == -1) {
                fill_sides_dfs(i, 0);
            }
        }
        if (accumulate(sides.begin(), sides.end(), 0) * 2 > sides.size()) {
            for (char &part : sides) {
                part ^= 1;
            }
        }
    }

    void find_maximum_matching() {
        vector<char> visited(n);
        function<bool(int)> try_khun = [&](int v) {
            if (visited[v]) {
                return false;
            }
            visited[v] = true;
            for (int to : g[v]) {
                if (p[to] == -1) {
                    p[to] = v;
                    p[v] = to;
                    return true;
                }
            }
            for (int to : g[v]) {
                if (try_khun(p[to])) {
                    p[to] = v;
                    p[v] = to;
                    return true;
                }
            }
            return false;
        };
        for (bool run = 1; run; ) {
            run = 0;
            fill(visited.begin(), visited.end(), 0);
            for (int i = 0; i < n; ++i) {
                if (sides[i] && p[i] == -1 && try_khun(i)) {
                    run = 1;
                }
            }
        }
    }

    int n;
    GraphIterator<int> g;
    vector<char> sides;
    vector<int> p;
};

vector<vector<int>> minimum_path_cover(int n, const vector<pair<int, int>> &edges) {
    vector<pair<int, int>> bipartite_edges;
    for (const auto [u, v] : edges) {
        assert(0 <= u && u < v && v < n);
        bipartite_edges.push_back({u, n + v});
    }
    Solver solver(n, n, bipartite_edges);
    auto matching = solver.maximum_matching();
    vector<char> is_start(n, 1);
    vector<int> nxt(n, -1);
    for (const auto &edge : matching) {
        nxt[edge.first] = edge.second - n;
        is_start[edge.second - n] = 0;
    }
    vector<vector<int>> paths;
    for (int i = 0; i < n; ++i) {
        if (is_start[i]) {
            vector<int> path;
            for (int v = i; v != -1; v = nxt[v]) {
                path.push_back(v);
            }
            paths.push_back(path);
        }
    }
    return paths;
}

vector<int> maximum_antichain(int n, const vector<pair<int, int>> &edges) {
    vector<pair<int, int>> bipartite_edges;
    for (const auto [u, v] : edges) {
        assert(0 <= u && u < v && v < n);
        bipartite_edges.push_back({u, n + v});
    }
    Solver solver(n, n, bipartite_edges);
    auto mis = solver.maximum_independent_set();
    vector<char> taken(2 * n);
    for (int v : mis) {
        taken[v] = 1;
    }
    vector<int> res;
    for (int i = 0; i < n; ++i) {
        if (taken[i] && taken[i + n]) {
            res.push_back(i);
        }
    }
    return res;
}

bool onf(int i, int j) {
    return i >= 0 && i < n && j >= 0 && j < m;
}

pair<int, int> orig[max_n * max_n];

int main() {
//    freopen("input.txt", "r", stdin);
//    freopen("output.txt", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    n = 2 * n - 1;
    m = 2 * m - 1;
    int max_v = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> f[i][j];
            ans[i][j] = f[i][j];
            if (ans[i][j] == '.') {
                ans[i][j] = '#';
            }
            if (f[i][j] != '.') {
                ind[i][j] = max_v;
                orig[max_v] = MP(i, j);
                ++max_v;
            }
        }
    }
    int cnt_1 = 0;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (f[i][j] >= '0' && f[i][j] <= '9') {
                int cnt_n = 0;
                for (int k = 0; k < 8; ++k) {
                    int ni = i + di[k];
                    int nj = j + dj[k];
                    if (onf(ni, nj)) {
                        ++cnt_n;
                    }
                }
                if (f[i][j] - '0' == cnt_n) {
                    f[i][j] = '0';
                } else {
                    f[i][j] = '1';
                    cnt_1 += 1;
                }
            }
        }
    }
    for (int i = 1; i < n - 1; ++i) {
        f[i][1] = '_';
        f[i][m - 2] = '_';
    }
    for (int j  =1; j < m - 1; ++j) {
        f[1][j] = '_';
        f[n - 2][j] = '_';
    }
    DEBUG {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                cout << f[i][j];
            }
            cout << endl;
        }
    };
    vector<pair<int, int>> edges;
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            if (f[i][j] != '.') {
                continue;
            }
            if (i % 2 == 0) {
                if (f[i][j - 1] == '1' && f[i][j + 1] == '1') {
                    edges.emplace_back(ind[i][j - 1], ind[i][j + 1]);
                    LOG(ind[i][j - 1], ind[i][j + 1]);
                }
            } else if (j % 2 == 0){
                if (f[i - 1][j] == '1' && f[i + 1][j] == '1') {
                    edges.emplace_back(ind[i - 1][j], ind[i + 1][j]);
                }
            }
        }
    }
    Solver solver = Solver(max_v, edges);
    vector<pair<int, int>> res = solver.maximum_matching();
    if (res.size() * 2 != cnt_1) {
        puts("NO");
        return 0;
    }
//    puts("YES");
cout << "YES" << endl;
    for (pair<int, int> p : res) {
        pair<int, int> a = orig[p.F];
        pair<int, int> b = orig[p.S];
        ans[(a.F + b.F) / 2][(a.S + b.S) / 2] = '.';

    }
    for (int i= 0; i < n; ++i) {
        for (int j = 0 ; j < m; ++j) {
            cout << ans[i][j];
        }
        cout << "\n";
    }


    return 0;
}