#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int MAXN = 100 + 5;
const int inf = 0x3f3f3f3f;
const int dx[] = {1,-1,0,0};
const int dy[] = {0,0,1,-1};

template<const int MAXN,const int MAXM>
struct Max_Flow
{
	struct Edge
	{
		int next,to,flow;
	}e[MAXM<<1];
	int head[MAXN],etot;
	inline void add_one(int u,int v,int flow)
	{
		e[++etot] = (Edge){ head[u],v,flow};
		head[u] = etot;
	}
	inline void add_edge(int u,int v,int flow){ add_one(u,v,flow); add_one(v,u,0);}
	
	int n,s,t;
	int dep[MAXN], cur[MAXN];
	inline void init(int _n,int _s,int _t){ n=_n; s=_s; t=_t;}
	inline void clear(void){ etot = -1; memset(head,-1,sizeof(head));}
	Max_Flow(void){ clear();}
	inline bool bfs(void)
	{
		for(int i=1; i<=n; ++i) dep[i] = -1, cur[i] = head[i];
		queue<int> q;
		dep[s] = 0; q.push(s);
		while(q.size())
		{
			int u = q.front(); q.pop();
			for(int i=head[u]; ~i; i=e[i].next) if(e[i].flow)
			{
				int v = e[i].to;
				if(dep[v] == -1)
				{
					dep[v] = dep[u] + 1, q.push(v);
					if(v == t) return 1;
				}
			}
		}
		return 0;
	}
	int dfs(int u,int maxf)
	{
		if(u == t || !maxf) return maxf;
		int res = 0;
		for(int &i=cur[u], f; ~i; i=e[i].next)
			if(e[i].flow && dep[e[i].to] == dep[u] + 1 && (f = dfs(e[i].to, min(maxf, e[i].flow))))
			{
				e[i].flow -= f; e[i^1].flow += f;
				res += f; maxf -= f;
				if(!maxf) return res;
			}
		return res;
	}
	ll dinic(void)
	{
		ll res = 0;
		while(bfs()) res += dfs(s,inf);
		return res;
	}
	int getmatch(int u)
	{
		for(int i=head[u]; ~i; i=e[i].next)
			if(e[i].to != s && e[i^1].flow)
				return e[i].to;
		return -1;
	}
};

Max_Flow<MAXN * MAXN, MAXN * MAXN * 5> mf;

char s[MAXN][MAXN];
char ans[MAXN][MAXN];

int main(void)
{
	int n,m;
	scanf("%d%d",&n,&m);
	n = 2 * n - 1;
	m = 2 * m - 1;
	for(int i=1; i<=n; ++i)
		scanf("%s",s[i] + 1);
	
	auto getid = [&] (int i,int j)
	{
		return (i-1) * m + j;
	};
	auto getflag = [&] (int i,int j)
	{
		int flag = 0;
		if(i == 1 || i == n) flag |= 1;
		if(j == 1 || j == m) flag |= 2;
		return flag;
	};
	
	for(int i=1; i<=n; ++i)
		for(int j=1; j<=m; ++j)
			ans[i][j] = i % 2 == 1 && j % 2 == 1? s[i][j]: '#';
	
	int S = n * m + 1, T = S + 1;
	mf.init(T, S, T);
	
	int tot = 0;
	for(int i=1; i<=n; i+=2)
		for(int j=1; j<=m; j+=2)
		{
			int type = (i / 2 + j / 2) % 2;
			int flag = getflag(i,j);
			int need = flag == 3? 3: flag == 1 || flag == 2? 5: 8;
			int cur = need - (s[i][j] - '0');
			
			tot += cur;
			
			if(type == 1)
				mf.add_edge(S, getid(i,j), cur);
			else
				mf.add_edge(getid(i,j), T, cur);
			
			if(type == 1)
			{
				for(int k=0; k<4; ++k)
				{
					int x = i + dx[k] * 2;
					int y = j + dy[k] * 2;
					if(x < 1 || x > n || y < 1 || y > m) continue;
					
					if((flag != 0) ^ (getflag(x,y) != 0)) continue;
					
					if(flag == 1 && dx[k] != 0) continue;
					if(flag == 2 && dy[k] != 0) continue;
					
					mf.add_edge(getid(i,j), getid(x,y), 1);
				}
			}
		}
	
	if(tot % 2 || mf.dinic() != tot / 2)
	{
		printf("NO\n");
		return 0;
	}
	
	for(int i=1; i<=n; i+=2)
		for(int j=1; j<=m; j+=2)
		{
			int type = (i / 2 + j / 2) % 2;
			if(type != 1) continue;
			
			int oth = mf.getmatch(getid(i,j));
			if(oth == -1) continue;
			
			int x = (oth - 1) / m + 1;
			int y = (oth - 1) % m + 1;
			
			ans[(i + x) / 2][(j + y) / 2] = '.';
		}
	
	printf("YES\n");
	for(int i=1; i<=n; ++i)
		printf("%s\n",ans[i] + 1);
	return 0;
}