#include <bits/stdc++.h>

namespace NetWork_Flow
{
    using std::queue;
    const int INF=1e9;
    const int NN=8005,MM=int(1.5 * 4000*4000)+5;
    struct edge
    {
        int to,nxt,v;
    }e[MM<<1]; int cnt=1,head[NN],cur[NN],dep[NN],s,t;
    inline int addedge(int x,int y,int z)
    {
        // std::cerr << "addedge(" << x << ", " << y << ", " << z << ")\n";
        e[++cnt]=(edge){y,head[x],z}; head[x]=cnt;
        e[++cnt]=(edge){x,head[y],0}; head[y]=cnt;
        return cnt - 1;
    }
    #define to e[i].to
    inline bool BFS(void)
    {
        memset(dep,0,(t+1)*sizeof(int)); dep[s]=1;
        queue <int> q; q.push(s);
        while (!q.empty())
        {
            int now=q.front(); q.pop();
            for (int i=head[now];i;i=e[i].nxt)
            if (e[i].v&&!dep[to]) dep[to]=dep[now]+1,q.push(to);
        }
        return dep[t];
    }
    inline int DFS(int now,int tar,int dis)
    {
        if (now==tar) return dis; int ret=0;
        for (int& i=cur[now];i&&dis;i=e[i].nxt)
        if (e[i].v&&dep[to]==dep[now]+1)
        {
            int dist=DFS(to,tar,std::min(dis,e[i].v));
            if (!dist) dep[to]=INF;
            dis-=dist; ret+=dist; e[i].v-=dist; e[i^1].v+=dist;
            if (!dis) return ret;
        }
        if (!ret) dep[now]=0; return ret;
    }
    #undef to
    inline int Dinic(int ret=0)
    {
        while (BFS()) memcpy(cur,head,t+1<<2),ret+=DFS(s,t,INF); return ret;
    }
};

int n;
int ed[4005][4005];

int main() {
    std::ios::sync_with_stdio(false);
    std::cin >> n;
    using NetWork_Flow::s;
    using NetWork_Flow::t;
    using NetWork_Flow::addedge;
    
    s = 2 * n, t = 2 * n + 1;

    for(int i = 0; i < n; ++i) {
        using NetWork_Flow::addedge;
        std::string s; std::cin >> s;
        for(int j = 0; j < n; ++j){
            if(s[j] == '+')
                ed[i][j] = addedge(i, j + n, 1);
            else
                ed[i][j] = addedge(j + n, i, 1);
        }
    }

    int rs = 0, cs = 0;
    for(int i = 0, r; i < n; ++i) {
        std::cin >> r;
        if(r > 0) rs += r, addedge(s, i, r);
        if(r < 0) cs -= r, addedge(i, t, -r);
    }
    for(int i = 0, c; i < n; ++i) {
        std::cin >> c;
        if(c > 0) cs += c, addedge(i + n, t, c);
        if(c < 0) rs -= c, addedge(s, i + n, -c);
    }

    if(rs != cs) return std::cout << "No\n", 0;

    int max_flow = NetWork_Flow::Dinic();
    if(max_flow != rs) return std::cout << "No\n", 0;

    std::cout << "Yes\n";
    for(int i = 0; i < n; ++i) {
        using NetWork_Flow::e;
        for(int j = 0; j < n; ++j)
            std::cout << char('0' + (e[ed[i][j]].v == 0));
        std::cout << char(10);
    }

    return 0;
}