#pragma GCC optimize("O3")
#include<bits/stdc++.h>
using namespace std;

using pi = pair<int,int>;
#define sz(x) int((x).size())
template<class F> struct Dinic {
    struct Edge { int to, rev; F cap; };
    int N; vector<vector<Edge>> adj;
    void init(int _N) { N = _N; adj.resize(N); 
        //for(int i=0;i<N;i++)adj[i].reserve(N+2);
    } //0-based
    void ae(int a, int b, F cap, F rcap = 0) {
        //assert(min(cap,rcap) >= 0); // saved me > once
        adj[a].push_back({b,sz(adj[b]),cap});
        adj[b].push_back({a,sz(adj[a])-1,rcap});
        //return {a,sz(adj[a])-1};
    }
    F edgeFlow(pi loc) { // get flow along original edge
        const Edge& e = adj.at(loc.first).at(loc.second);
        return adj.at(e.to).at(e.rev).cap;
    }
    vector<int> lev, ptr;
    bool bfs(int s,int t){//level=shortest dist from source
        lev = ptr = vector<int>(N);
        lev[s] = 1; queue<int> q({s});
        while (sz(q)) { int u = q.front(); q.pop();
            for(auto& e: adj[u]) if (e.cap && !lev[e.to]) {
                q.push(e.to), lev[e.to] = lev[u]+1;
                if (e.to == t) return 1;
            }
        }
        return 0;
    }
    F dfs(int v, int t, F flo) {
        if (v == t) return flo;
        for (int& i = ptr[v]; i < sz(adj[v]); i++) {
            Edge& e = adj[v][i];
            if (lev[e.to]!=lev[v]+1||!e.cap) continue;
            if (F df = dfs(e.to,t,min(flo,e.cap))) {
                e.cap -= df; adj[e.to][e.rev].cap += df;
                return df; } // saturated $\geq1$ one edge
        }
        return 0;
    }
    F maxFlow(int s, int t,int ttt) {
        F tot = 0; while (bfs(s,t)) while (F df =
            dfs(s,t,numeric_limits<F>::max())) {
            tot += df;
        }
        return tot;
    }
};

void solve(int t){
    int n;
    cin>>n;
    //n=2000;
    
    vector mat(n,vector(n,'.'));
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>mat[i][j];
            //mat[i][j]='+';
        }
    }
    
    vector r(n,0),c(n,0);
    
    for(int i=0;i<n;i++)cin>>r[i];
    for(int i=0;i<n;i++)cin>>c[i];
    
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            if(mat[i][j]=='-'){
                r[i]++;
                c[j]++;
            }
        }
    }
    
    long long totr=0,totc=0;
    for(int i=0;i<n;i++){
        if(r[i]<0 || c[i]<0 || r[i]>n || c[i]>n){
            cout<<"No\n";
            return;
        }
        totr+=r[i];
        totc+=c[i];
    }
    
    if(totr!=totc){
        cout<<"No\n";
    }else{
        vector ok(n,vector<int>(n,-1));
        vector<int> dispr(n,n), dispc(n,n);
        
        queue<pair<int,int>> gg;
        for(int i=0;i<n;i++){
            if(r[i]==0 || r[i]==n){
                gg.push({i,0});
            }
            if(c[i]==0 || c[i]==n){
                gg.push({i,1});
            }
        }
        
        vector<bool> okr(n,false),okc(n,false);
        while(n>1200 && !gg.empty()){
            
            auto [x,y] = gg.front();
            gg.pop();
            //cout<<"fixo "<<x<<" "<<(y==0 ? "colonna" : "riga")<<"\n";
            
            if(y==0){
                okr[x]=true;
                if(r[x]==0){
                    for(int i=0;i<n;i++){
                        if(ok[x][i]==-1){
                            ok[x][i]=0;
                            dispc[i]--;
                            if(dispc[i]==c[i]){
                                gg.push({i,1});
                            }
                            if(dispc[i]<c[i]){
                                cout<<"No\n";
                                return;
                            }
                        }
                    }
                }else{
                    totr-=r[x];
                    for(int i=0;i<n;i++){
                        if(ok[x][i]==-1){
                            ok[x][i]=1;
                            c[i]--;
                            dispc[i]--;
                            if(c[i]==0){
                                gg.push({i,1});
                            }
                            if(c[i]<0){
                                cout<<"No\n";
                                return;
                            }
                        }
                    }
                }
            }else{
                okc[x]=true;
                if(c[x]==0){
                    for(int i=0;i<n;i++){
                        if(ok[i][x]==-1){
                            ok[i][x]=0;
                            dispr[i]--;
                            if(dispr[i]==r[i]){
                                gg.push({i,0});
                            }
                            if(dispr[i]<r[i]){
                                cout<<"No\n";
                                return;
                            }
                        }
                    }
                }else{
                    for(int i=0;i<n;i++){
                        if(ok[i][x]==-1){
                            ok[i][x]=1;
                            r[i]--;
                            dispr[i]--;
                            totr--;
                            if(r[i]==0){
                                gg.push({i,0});
                            }
                            if(r[i]<0){
                                cout<<"No\n";
                                return;
                            }
                        }
                    }
                }
            }
        }
        
        Dinic<long long> ds;
        int source = 2*n;
        int sink = 2*n+1;
        ds.init(2*n+2);
        
        for(int i=0;i<n;i++){
assert(r[i]>=0 && c[i]>=0);
            if(okr[i]==false)
            ds.ae(source,i,r[i]);
            if(okc[i]==false)
            ds.ae(n+i,sink,c[i]);
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(ok[i][j]==-1){
                    ds.ae(i,n+j,1);
                    ok[i][j]=0;
                }
                
            }
        }
        
        if(ds.maxFlow(source,sink,totr)!=totr){
            cout<<"No\n";
        }else{
            for(int i=0;i<n;i++){
                for(auto j : ds.adj[i]){
                    if(j.to>=n && j.cap==0){
                        ok[i][j.to-n]=true;
                    }
                }
            }
            
            cout<<"Yes\n";
            
            
            for(int i=0;i<n;i++){
                string tmp;
                tmp.resize(n);
                for(int j=0;j<n;j++){
                    if(ok[i][j]^(mat[i][j]=='+')){
                        tmp[j]='0';
                    }else{
                        tmp[j]='1';
                    }
                }
                cout<<tmp<<"\n";
            }
        }
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int t=1;
    //cin>>t;
    for(int i=1;i<=t;i++)solve(i);
    
    return 0;
}