#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MAXN = 4e3 + 100;
int r[MAXN], c[MAXN];
string ans[MAXN];


int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n;
    cin >> n;
    vector<array<int, 2>> minus;
    for (int i = 0; i < n; ++i) {
        string s;
        cin >> s;
        for (int j = 0; j < n; ++j) {
            if (s[j] == '-') {
                minus.push_back({i, j});
                ++r[i];
                ++c[j];
            }
        }
        ans[i].resize(n, '0');
    }

    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        r[i] += x;
    }
    for (int i = 0; i < n; ++i) {
        int x;
        cin >> x;
        c[i] += x;
    }

    int sumr = 0, sumc = 0;
    for (int i = 0; i < n; ++i) {
        if (r[i] < 0 || r[i] > n || c[i] < 0 || c[i] > n) {
            cout << "No\n";
            return 0;
        }
        sumr += r[i];
        sumc += c[i];
    }
    if (sumr != sumc) {
        cout << "No\n";
        return 0;
    }

    vector<int> ordr(n);
    vector<int> ordc(n);
    iota(ordr.begin(), ordr.end(), 0);
    ordc = ordr;

    sort(ordr.begin(), ordr.end(), [](int i, int j) { return r[i] > r[j]; });
    sort(ordc.begin(), ordc.end(), [](int i, int j) { return c[i] > c[j]; });

    for (int i : ordr) {
        /// cerr << i << endl;
        for (int j = 0; j < r[i]; ++j) {
            ans[i][ordc[j]] = '1';
            --c[ordc[j]];
            if (c[ordc[j]] < 0) {
                cout << "No\n";
                return 0;
            }
        }
        if (r[i] != n && r[i] != 0 && c[ordc[r[i]]] > c[ordc[r[i] - 1]]) {
            int L = r[i] - 1;
            int R = r[i];
            while (R + 1 < n && c[ordc[R + 1]] == c[ordc[R]]) ++R;
            while (L - 1 >= 0 && c[ordc[L - 1]] == c[ordc[L]]) --L;
            rotate(ordc.begin() + L, ordc.begin() + r[i], ordc.begin() + R + 1);
        }
    }

    cout << "Yes\n";
    for (auto elem : minus) {
        ans[elem[0]][elem[1]] = '0' + '1' - ans[elem[0]][elem[1]];
    }

    for (int i = 0; i < n; ++i) {
        cout << ans[i] << "\n";
    }

    return 0;
}