#include <bits/stdc++.h>
#ifdef LOCAL
#include <debug.hpp>
#else
#define debug(...) void(0)
#endif

template <class T> std::istream& operator>>(std::istream& is, std::vector<T>& v) {
    for (auto& e : v) {
        is >> e;
    }
    return is;
}

template <class T> std::ostream& operator<<(std::ostream& os, const std::vector<T>& v) {
    for (std::string_view sep = ""; const auto& e : v) {
        os << std::exchange(sep, " ") << e;
    }
    return os;
}

template <class T, class U = T> bool chmin(T& x, U&& y) {
    return y < x and (x = std::forward<U>(y), true);
}

template <class T, class U = T> bool chmax(T& x, U&& y) {
    return x < y and (x = std::forward<U>(y), true);
}

template <class T> void mkuni(std::vector<T>& v) {
    std::ranges::sort(v);
    auto result = std::ranges::unique(v);
    v.erase(result.begin(), result.end());
}

template <class T> int lwb(const std::vector<T>& v, const T& x) {
    return std::distance(v.begin(), std::ranges::lower_bound(v, x));
}

using ll = long long;

using namespace std;

constexpr int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};

int topbit(signed t) { return t == 0 ? -1 : 31 - __builtin_clz(t); }
int topbit(long long t) { return t == 0 ? -1 : 63 - __builtin_clzll(t); }
int botbit(signed a) { return a == 0 ? 32 : __builtin_ctz(a); }
int botbit(long long a) { return a == 0 ? 64 : __builtin_ctzll(a); }
int popcount(signed t) { return __builtin_popcount(t); }
int popcount(long long t) { return __builtin_popcountll(t); }
bool ispow2(int i) { return i && (i & -i) == i; }
long long MSK(int n) { return (1LL << n) - 1; }

bool check(int n,
           int m,
           const vector<char>& U,
           const vector<char>& L,
           const vector<char>& R,
           const vector<char>& D,
           const vector<vector<char>>& ans) {
    for (int i = 0; i < n; i++) {
        if (isupper(L[i])) {
            bool ok = false;
            for (int j = 0; j < m; j++) {
                if (not isupper(ans[i][j])) continue;
                if (ans[i][j] != L[i]) return false;
                ok = true;
                break;
            }
            if (not ok) return false;
        }
        if (isupper(R[i])) {
            bool ok = false;
            for (int j = m - 1; j >= 0; j--) {
                if (not isupper(ans[i][j])) continue;
                if (ans[i][j] != R[i]) return false;
                ok = true;
                break;
            }
            if (not ok) return false;
        }
    }
    for (int j = 0; j < m; j++) {
        if (isupper(U[j])) {
            bool ok = false;
            for (int i = 0; i < n; i++) {
                if (not isupper(ans[i][j])) continue;
                if (ans[i][j] != U[j]) return false;
                ok = true;
                break;
            }
            if (not ok) return false;
        }
        if (isupper(D[j])) {
            bool ok = false;
            for (int i = n - 1; i >= 0; i--) {
                if (not isupper(ans[i][j])) continue;
                if (ans[i][j] != D[j]) return false;
                ok = true;
                break;
            }
            if (not ok) return false;
        }
    }
    return true;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(15);

    int n, m;
    cin >> n >> m;
    vector<char> U(m), L(n), R(n), D(m);
    vector S(n, vector<char>(m));
    {
        char tmp;
        cin >> tmp;
        for (int i = 0; i < m; i++) cin >> U[i];
        cin >> tmp;
        for (int i = 0; i < n; i++) {
            cin >> L[i];
            for (int j = 0; j < m; j++) cin >> S[i][j];
            cin >> R[i];
        }
        cin >> tmp;
        for (int i = 0; i < m; i++) cin >> D[i];
        cin >> tmp;
    }

    vector<vector<char>> cond;
    cond.emplace_back(U);
    cond.emplace_back(L);
    cond.emplace_back(D);
    cond.emplace_back(R);
    vector wait(n, vector<vector<int>>(m));
    for (int i = 0; i < n; i++) {
        if (isupper(cond[1][i])) wait[i][0].emplace_back(1);
        if (isupper(cond[3][i])) wait[i][m - 1].emplace_back(3);
    }
    for (int j = 0; j < m; j++) {
        if (isupper(cond[0][j])) wait[0][j].emplace_back(0);
        if (isupper(cond[2][j])) wait[n - 1][j].emplace_back(2);
    }

    queue<pair<int, int>> que;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (S[i][j] == 'x') {
                que.emplace(i, j);
            } else {
                int mask = 0;
                for (int idx : wait[i][j]) {
                    char c = cond[idx][idx & 1 ? i : j];
                    mask |= 1 << (c - 'A');
                }
                if (popcount(mask) > 1) {
                    S[i][j] = 'x';
                    que.emplace(i, j);
                }
            }
        }
    }

    auto isin = [&](int x, int y) { return 0 <= x and x < n and 0 <= y and y < m; };
    while (not que.empty()) {
        auto [x, y] = que.front();
        que.pop();
        assert(S[x][y] == 'x');
        for (int idx : wait[x][y]) {
            int nx = x, ny = y;
            while (isin(nx, ny) and S[nx][ny] == 'x') {
                nx += dx[idx];
                ny += dy[idx];
            }
            if (not isin(nx, ny)) {
                cout << "NO\n";
                return 0;
            }
            wait[nx][ny].emplace_back(idx);
            int mask = 0;
            for (int idx : wait[nx][ny]) {
                char c = cond[idx][idx & 1 ? nx : ny];
                mask |= 1 << (c - 'A');
            }
            if (popcount(mask) > 1) {
                S[nx][ny] = 'x';
                que.emplace(nx, ny);
            }
        }
        wait[x][y].clear();
    }

    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (S[i][j] == 'x') {
                assert(wait[i][j].empty());
                continue;
            }
            int mask = 0;
            for (int idx : wait[i][j]) {
                char c = cond[idx][idx & 1 ? i : j];
                mask |= 1 << (c - 'A');
            }
            assert(popcount(mask) <= 1);
            if (popcount(mask) == 1) S[i][j] = char('A' + topbit(mask));
        }
    }

    cout << "YES\n";
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) cout << (isupper(S[i][j]) ? S[i][j] : '.');
        cout << "\n";
    }
    return 0;
}