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

using ll = long long;
using db = long double; // or double if tight TL
using str = string;

using pi = pair<int,int>;
#define mp make_pair
#define f first
#define s second

#define tcT template<class T
tcT> using V = vector<T>; 
tcT, size_t SZ> using AR = array<T,SZ>;
using vi = V<int>;
using vb = V<bool>;
using vpi = V<pi>;

#define sz(x) int((x).size())
#define all(x) begin(x), end(x)
#define sor(x) sort(all(x))
#define rsz resize
#define pb push_back
#define ft front()
#define bk back()

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define F0R(i,a) FOR(i,0,a)
#define ROF(i,a,b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i,a) ROF(i,0,a)
#define rep(a) F0R(_,a)
#define each(a,x) for (auto& a: x)

const int MOD = 1e9+7;
const db PI = acos((db)-1);
mt19937 rng(0); // or mt19937_64

tcT> bool ckmin(T& a, const T& b) {
    return b < a ? a = b, 1 : 0; } // set a = min(a,b)
tcT> bool ckmax(T& a, const T& b) {
    return a < b ? a = b, 1 : 0; } // set a = max(a,b)


template <int SZ> struct HLPP {
    typedef short F; // flow type
    struct Edge { int to, rev; F f; };
    const F INF = numeric_limits<F>::max();
    
    int N,s,t;
    V<Edge> adj[SZ];
    void ae(int u, int v, F cap) {
        assert(cap >= 0); // don't try smth dumb
        Edge a{v, sz(adj[v]), cap}, b{u, sz(adj[u]), 0};
        adj[u].pb(a), adj[v].pb(b);
    }
    
    vi lst[SZ], gap[SZ];
    F excess[SZ];
    int highest, height[SZ], cnt[SZ], work;
    void updHeight(int v, int nh) {
        work++;
        if (height[v] != N) cnt[height[v]]--;
        height[v] = nh;
        if (nh == N) return;
        cnt[nh]++, highest = nh;
        gap[nh].pb(v);
        if (excess[v] > 0) lst[nh].pb(v);
    }
    void globalRelabel() {
        work = 0;
        F0R(i,N) height[i] = N, cnt[i] = 0;
        F0R(i,highest) lst[i].clear(), gap[i].clear();
        height[t] = 0;
        queue<int> q({t});
        while (sz(q)) {
            int v = q.ft; q.pop();
            each(e,adj[v])
            if (height[e.to] == N && adj[e.to][e.rev].f > 0)
                q.push(e.to), updHeight(e.to, height[v] + 1);
            highest = height[v];
        }
    }
    void push(int v, Edge& e) {
        if (excess[e.to] == 0) lst[height[e.to]].pb(e.to);
        F df = min(excess[v], e.f);
        e.f -= df, adj[e.to][e.rev].f += df;
        excess[v] -= df, excess[e.to] += df;
    }
    void discharge(int v) {
        int nh = N;
        each(e,adj[v]) {
            if (e.f > 0) {
                if (height[v] == height[e.to] + 1) {
                    push(v, e);
                    if (excess[v] <= 0) return;
                } else ckmin(nh,height[e.to]+1);
            }
        }
        if (cnt[height[v]] > 1) updHeight(v, nh);
        else {
            FOR(i,height[v],highest+1) {
                each(j,gap[i]) updHeight(j, N);
                gap[i].clear();
            }
        }
    }
    F maxFlow(int _N, int _s, int _t) {
        N = _N, s = _s, t = _t; if (s == t) return -1;
        F0R(i,N) excess[i] = 0;
        excess[s] = INF, excess[t] = -INF;
        globalRelabel();
        each(e,adj[s]) push(s,e);
        for (; highest >= 0; highest--) 
            while (sz(lst[highest])) {
            int v = lst[highest].bk;
            lst[highest].pop_back();
            discharge(v);
            if (work > 4*N) globalRelabel();
        }
        return excess[t]+INF;
    }
};

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{
        HLPP<8002> ds;
        int source = 2*n;
        int sink = 2*n+1;
        //ds.init(2*n+2);
        
        for(int i=0;i<n;i++){
            ds.ae(source,i,r[i]);
            ds.ae(n+i,sink,c[i]);
        }
        
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                ds.ae(i,n+j,1);
            }
        }
        
        if(ds.maxFlow(8002,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.to>=n && j.f==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;
}