#include <bits/stdc++.h>
#define long long long int
#define DEBUG
using namespace std;

// @author: pashka

struct maxflow {
    struct edge {
        int src, dst, cap, flw;
    };

    vector<edge> edges;
    vector<vector<int>> graph;
    vector<int> first;
    vector<int> dist;

    maxflow(int n) {
        graph.resize(n);
    }

    void bfs(int s) {
        dist.assign(graph.size(), -1);
        dist[s] = 0;
        int h = 0;
        vector<int> q;
        q.push_back(s);
        while (h < q.size()) {
            int x = q[h++];
            for (int i = 0; i < graph[x].size(); i++) {
                edge& e = edges[graph[x][i]];
                if (e.flw == e.cap) continue;
                int y = e.dst;
                if (dist[y] == -1) {
                    dist[y] = dist[x] + 1;
                    q.push_back(y);
                }
            }
        }
    }

    int dfs(int x, int t, int f) {
        if (f == 0) return 0;
        if (x == t) return f;
        for (int i = first[x]; i < graph[x].size(); i++) {
            first[x] = i;
            edge& e = edges[graph[x][i]];
            edge& er = edges[graph[x][i] ^ 1];
            if (e.flw == e.cap || dist[e.dst] != dist[e.src] + 1)
                continue;
            int y = e.dst;
            int res = dfs(y, t, std::min(f, e.cap - e.flw));
            if (res > 0) {
                e.flw += res;
                er.flw -= res;
                return res;
            }
        }
        return 0;
    }

    long maxFlow(int s, int t) {
        long flow = 0;
        while (true) {
            bfs(s);
            first.assign(graph.size(), 0);
            if (dist[t] == -1) break;
            while (true) {
                int pushed = dfs(s, t, INT_MAX);
                if (pushed > 0) {
                    flow += pushed;
                } else {
                    break;
                }
            }
        }
        return flow;
    }

    void addEdge(int u, int v, int cap) {
        //    cout << u << " " << v << "\n";
        edges.push_back({u, v, cap, 0});
        edges.push_back({v, u, 0, 0});
        graph[u].push_back(edges.size() - 2);
        graph[v].push_back(edges.size() - 1);
    }
};


int main() {
    ios::sync_with_stdio(false);

    int n;
    cin >> n;
    vector<string> a(n);
    for (int i = 0; i < n; i++) cin >> a[i];
    vector<int> r(n), c(n);
    for (int i = 0; i < n; i++) cin >> r[i];
    for (int i = 0; i < n; i++) cin >> c[i];

    maxflow mf(2 * n + 2);
    int s = 2 * n;
    int t = 2 * n + 1;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (a[i][j] == '+') {
                mf.addEdge(i, n + j, 1);
            } else {
                mf.addEdge(n + j, i, 1);
            }
        }
    }
    int ff = 0;
    for (int i = 0; i < n; i++) {
        ff += abs(r[i]);
        if (r[i] > 0) {
            mf.addEdge(s, i, r[i]);
        } else {
            mf.addEdge(i, t, -r[i]);
        }
    }
    for (int i = 0; i < n; i++) {
        ff += abs(c[i]);
        if (c[i] < 0) {
            mf.addEdge(s, n + i, -c[i]);
        } else {
            mf.addEdge(n + i, t, c[i]);
        }
    }
    int f = mf.maxFlow(s, t);
    if (f * 2 != ff) {
        cout << "No\n";
    } else {
        cout << "Yes\n";
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                int k = i * n + j;
                if (mf.edges[k * 2].flw) {
                    cout << '1';
                } else {
                    cout << '0';
                }
            }
            cout << "\n";
        }
    }

    return 0;
}