/*
    author:  Maksim1744
    created: 22.02.2025 15:08:10
*/

#include "bits/stdc++.h"

using namespace std;

using ll = long long;
using ld = long double;

#define mp   make_pair
#define pb   push_back
#define eb   emplace_back

#define sum(a)     ( accumulate ((a).begin(), (a).end(), 0ll))
#define mine(a)    (*min_element((a).begin(), (a).end()))
#define maxe(a)    (*max_element((a).begin(), (a).end()))
#define mini(a)    ( min_element((a).begin(), (a).end()) - (a).begin())
#define maxi(a)    ( max_element((a).begin(), (a).end()) - (a).begin())
#define lowb(a, x) ( lower_bound((a).begin(), (a).end(), (x)) - (a).begin())
#define uppb(a, x) ( upper_bound((a).begin(), (a).end(), (x)) - (a).begin())

#define fr first
#define sc second
#define all(a) (a).begin(), (a).end()

#ifdef ONPC
mt19937 rnd(223);
#else
mt19937 rnd(chrono::high_resolution_clock::now()
                        .time_since_epoch().count());
#endif


template<typename T, typename U> pair<T,U>& operator--           (pair<T, U> &p){--p.first; --p.second;            return  p;}
template<typename T, typename U> pair<T,U>& operator++           (pair<T, U> &p){++p.first; ++p.second;            return  p;}
template<typename T, typename U> istream& operator>>(istream& is, pair<T, U> &p){is >> p.first >> p.second;        return is;}
template<typename T, typename U> ostream& operator<<(ostream& os, pair<T, U>  p){os << p.first << ' ' << p.second; return os;}
template<typename T>             vector<T>& operator--            (vector<T> &v){for (auto& i : v) --i;            return  v;}
template<typename T>             vector<T>& operator++            (vector<T> &v){for (auto& i : v) ++i;            return  v;}
template<typename T>             istream& operator>>(istream& is,  vector<T> &v){for (auto& i : v) is >> i;        return is;}
template<typename T>             ostream& operator<<(ostream& os,  vector<T>  v){for (auto& i : v) os << i << ' '; return os;}
template<typename T, typename U> pair<T,U> operator-(pair<T,U> a, pair<T,U> b){return mp(a.first-b.first, a.second-b.second);}
template<typename T, typename U> pair<T,U> operator+(pair<T,U> a, pair<T,U> b){return mp(a.first+b.first, a.second+b.second);}
template<typename T, typename U> void setmin(T& a, U b){if (a > b) a = b;}
template<typename T, typename U> void setmax(T& a, U b){if (a < b) a = b;}

#ifdef HOME
#define SHOW_COLORS
#include "/home/team/tools/programming-library/tools/print.cpp"
#else
#define show(...) void(0)
#define debugf(fun)   fun
#define debugv(var)   var
#define mclock    void(0)
#define shows     void(0)
#define debug  if (false)
#define OSTREAM(...)    ;
#define OSTREAM0(...)   ;
#endif

vector<string> flipi(vector<string> v) {
    reverse(all(v));
    return v;
}

vector<string> flipj(vector<string> v) {
    for (auto& s : v) {
        reverse(all(s));
    }
    return v;
}

vector<string> trans(const vector<string>& v) {
    if (v.empty()) {
        return v;
    }
    vector<string> res(v[0].size(), string(v.size(), ' '));
    for (int i = 0; i < v.size(); ++i) {
        for (int j = 0; j < v[i].size(); ++j) {
            res[j][i] = v[i][j];
        }
    }
    return res;
}

namespace grid_iterator_ns {
const array<pair<int, int>, 8> dirs = {{{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {1, 1}, {-1, -1}, {1, -1}, {-1, 1}}};
struct GridIterator {
    int n, m;
    GridIterator(int n, int m) : n(n), m(m) {}

    template<size_t N>
    struct NeighbourIteratorContainer {
        int i, j, n, m;
        NeighbourIteratorContainer(int i, int j, int n, int m) : i(i), j(j), n(n), m(m) {}

        struct NeighbourIterator {
            int cur;
            int i, j, n, m;
            NeighbourIterator(int cur, int i, int j, int n, int m) : cur(cur), i(i), j(j), n(n), m(m) {
                skip_to_first_allowed();
            }

            void skip_to_first_allowed() {
                while (cur < N &&
                    (i + dirs[cur].first  < 0 || i + dirs[cur].first  >= n ||
                     j + dirs[cur].second < 0 || j + dirs[cur].second >= m)) {
                    ++cur;
                }
            }

            NeighbourIterator& operator ++ () {
                ++cur;
                skip_to_first_allowed();
                return *this;
            }

            pair<int, int> operator * () const { return {i + dirs[cur].first, j + dirs[cur].second}; }

            bool operator == (const NeighbourIterator& other) const { return cur == other.cur; }
            bool operator != (const NeighbourIterator& other) const { return cur != other.cur; }
        };

        auto begin() const { return NeighbourIterator(0, i, j, n, m); }
        auto end()   const { return NeighbourIterator(N, i, j, n, m); }

        auto collect() const {
            vector<pair<int, int>> result;
            for (auto it = begin(); it != end(); ++it) result.push_back(*it);
            return result;
        }
    };

    template<size_t N>
    auto iterate(int i, int j) const {
        static_assert(N == 4 || N == 8, "you can remove this, but make sure you understand what you are doing");
        return NeighbourIteratorContainer<N>(i, j, n, m);
    }
};
}
using grid_iterator_ns::GridIterator;


vector<string> solve(int n, int m, int i, int j, int x) {
    show(n, m, i, j, x);
    if (i > n - 1 - i) {
        return flipi(solve(n, m, n - 1 - i, j, x));
    }
    if (j > m - 1 - j) {
        return flipj(solve(n, m, i, m - 1 - j, x));
    }
    if (min(n, m) <= 2 && n > m) {
        return trans(solve(m, n, j, i, x));
    }
    if (n == 1) {
        if (x < j + 1) {
            return {};
        }
        vector<string> v(1, string(m, '.'));
        for (int k = x; k < m; ++k) {
            v[0][k] = '#';
        }
        return v;
    }
    if (n == 2) {
        assert(i == 0);
        int min_white = m - 2;
        if (j == 0) {
            min_white += 1;
        }
        if (x < min_white) {
            return {};
        }
        vector<string> v(2, string(m, '.'));
        int need_black = n * m - x;
        int have_black = 0;
        // show(need_black);
        auto add = [&](int x, int y) {
            if (i == x && j == y) {
                return;
            }
            // show(x, y, have_black, need_black);
            if (have_black >= need_black) return;
            have_black += 1;
            v[x][y] = '#';
        };
        add(0, 0);
        for (int k = 0; k < m; ++k) {
            add(1, k);
        }
        add(0, m - 1);
        return v;
    }
    if (j == 0 && i != 0) {
        return trans(solve(m, n, j, i, x));
    }
    int max_black = n * m - (n - 2) * (m - 2) + (n - 3) * (m - 3) / 2;
    set<pair<int, int>> bad;
    if (i == 0) {
        --max_black;
        bad.emplace(0, j);
        if (j == 0) {
            bad.emplace(0, 1);
            --max_black;
        }
    }
    int min_white = n * m - max_black;
    show(n, m, i, j, x, min_white, max_black);
    if (x < min_white) {
        return {};
    }
    int skip_col = j;
    if (i == 0) skip_col = 1;
    vector<string> res(n, string(m, '.'));
    int need_black = n * m - x;
    int have_black = 0;
    auto add = [&](int x, int y) {
        show(x, y, have_black, need_black);
        if (bad.count({x, y})) return;
        if (have_black >= need_black) return;
        have_black += 1;
        res[x][y] = '#';
    };
    for (int i = 1; i + 1 < n; ++i) {
        res[i][0] = '#';
        res[i].back() = '#';
        have_black += 2;
    }
    res[0] = string(m, '#');
    res.back() = string(m, '#');
    have_black += m * 2;
    show(have_black, bad);
    for (auto [i, j] : bad) {
        res[i][j] = '.';
        have_black -= 1;
    }
    show(have_black);

    for (int i = 2; i + 2 < n; i += 2) {
        for (int j = 1; j < skip_col; ++j) {
            add(i, j);
        }
        for (int j = m - 2; j > skip_col; --j) {
            add(i, j);
        }
    }
    if (n % 2 == 0) {
        for (int j = 2; j <= skip_col; j += 2) {
            add(n - 2, j);
        }
        for (int j = m - 3; j > skip_col; j -= 2) {
            add(n - 2, j);
        }
    }
    if (i == 0) {
        res[0][j] = '.';
        if (j == 0) {
            res[0][1] = '.';
        }
    }

    GridIterator gi(n, m);

    set<pair<int, pair<int, int>>> rem;
    vector<vector<int>> deg(n, vector<int>(m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            int dd = 0;
            if (res[i][j] == '#') {
                for (auto [x, y] : gi.iterate<4>(i, j)) {
                    if (res[x][y] == '#') {
                        dd++;
                    }
                }
                rem.emplace(dd, mp(i, j));
                deg[i][j] = dd;
            }
        }
    }
    show(need_black, rem.size());
    show(res);
    while (rem.size() > need_black) {
        int i, j;
        if (rem.begin()->first == 2) {
            i = 0;
            j = 1;
            rem.erase({2, {i, j}});
        } else {
            auto [_, who] = *rem.begin();
            rem.erase(rem.begin());
            tie(i, j) = who;
        }
        res[i][j] = '.';
        for (auto [x, y] : gi.iterate<4>(i, j)) {
            if (res[x][y] == '#') {
                rem.erase({deg[x][y], mp(x, y)});
                deg[x][y] -= 1;
                rem.insert({deg[x][y], mp(x, y)});
            }
        }
    }
    return res;
}

void test_case(int test) {
    int n, m;
    cin >> n >> m;
    int i, j, x;
    cin >> i >> j >> x;
    --i; --j;
    // for (int n = 1; n <= 10; ++n) {
    //     for (int m = 1; m <= 10; ++m) {
    //         for (int i = 0; i < n; ++i) {
    //             for (int j = 0; j < m; ++j) {
    //                 for (int x = 1; x <= n * m; ++x) {
    //                     auto v = solve(n, m, i, j, x);
    //                     cout << n << ' ' << m << ' ' << i << ' ' << j << ' ' << x << endl;
    //                     for (const auto& s : v) {
    //                         cout << s << '\n';
    //                     }
    //                     cout << '\n';
    //                     if (!v.empty()) {
    //                         cout.flush();
    //                         assert(v.size() == n);
    //                         assert(v[0].size() == m);
    //                         assert(v[i][j] == '.');
    //                         int cnt = 0;
    //                         for (const auto& s : v) {
    //                             cnt += count(all(s), '.');
    //                         }
    //                         assert(cnt == x);
    //                     }
    //                 }
    //             }
    //         }
    //     }
    // }
    // exit(0);
    auto v = solve(n, m, i, j, x);
    if (v.empty()) {
        cout << "No\n";
    } else {
        cout << "Yes\n";
        for (const auto& l : v) {
            cout << l << '\n';
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(NULL);

    int T;
    cin >> T;
    for (int test = 1; test <= T; ++test) {
        test_case(test);
    }

    return 0;
}