#include<bits/stdc++.h>
using namespace std;

template<int V, class T=int>
class max_flow {
    static const T INF = numeric_limits<T>::max();
    
public:
    struct edge {
        int t, rev;
        T cap, f;
    };
    
    vector<edge> adj[V];
    int dist[V];
    int ptr[V];
    
    bool bfs(int s, int t) {
        memset(dist, -1, sizeof dist);
        dist[s] = 0;
        queue<int> q({ s });
        while (!q.empty() && dist[t] == -1) {
            int n = q.front();
            q.pop();
            for (auto& e : adj[n]) {
                if (dist[e.t] == -1 && e.cap != e.f) {
                    dist[e.t] = dist[n] + 1;
                    q.push(e.t);
                }
            }
        }
        return dist[t] != -1;
    }
    
    T augment(int n, T amt, int t) {
        if (n == t) return amt;
        for (; ptr[n] < adj[n].size(); ptr[n]++) {
            edge& e = adj[n][ptr[n]];
            if (dist[e.t] == dist[n] + 1 && e.cap != e.f) {
                T flow = augment(e.t, min(amt, e.cap - e.f), t);
                if (flow != 0) {
                    e.f += flow;
                    adj[e.t][e.rev].f -= flow;
                    return flow;
                }
            }
        }
        return 0;
    }

    void add(int u, int v, T cap=1, T rcap=0) {
        adj[u].push_back({ v, (int) adj[v].size(), cap, 0 });
        adj[v].push_back({ u, (int) adj[u].size() - 1, rcap, 0 });
    }
    
    T calc(int s, int t) {
        T flow = 0;
        while (bfs(s, t)) {
            memset(ptr, 0, sizeof ptr);
            while (T df = augment(s, INF, t))
                flow += df;
        }
        return flow;
    }
    
    void clear() {
        for (int n = 0; n < V; n++)
            adj[n].clear();
    }
};

void solve(int t){
    int n;
    cin>>n;
    
    vector mat(n,vector(n,'.'));
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            cin>>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){
            cout<<"No\n";
            return;
        }
        totr+=r[i];
        totc+=c[i];
    }
    
    if(totr!=totc){
        cout<<"No\n";
    }else{
        max_flow<8002> ds;
        int source = 2*n;
        int sink = 2*n+1;
        //ds.init(2*n+2);
        
        for(int i=0;i<n;i++){
            ds.add(source,i,r[i]);
            ds.add(n+i,sink,c[i]);
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                ds.add(i,n+j,1);
            }
        }
        
        if(ds.calc(source,sink)!=totr){
            cout<<"No\n";
        }else{
            vector ok(n,vector(n,false));
            
            for(int i=0;i<n;i++){
                for(auto j : ds.adj[i]){
                    if(j.t>=n && j.f==1){
                        ok[i][j.t-n]=true;
                    }
                }
            }
            
            cout<<"Yes\n";
            for(int i=0;i<n;i++){
                for(int j=0;j<n;j++){
                    if((ok[i][j]^(mat[i][j]=='-'))==false){
                        cout<<"0";
                    }else{
                        cout<<"1";
                    }
                }
                cout<<"\n";
            }
        }
    }
}

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