#include <bits/stdc++.h>

using namespace std;

#pragma GCC target("avx2")
#pragma GCC optimize("O3")

void solve() {
    auto start = clock();

    int n, na, nb, nc;
    cin >> n >> na >> nb >> nc;

    vector<int> x(n);
    vector<int> where(n);

    vector<int> lina;
    vector<int> linb;
    vector<int> linc;

    set<int> ina;
    set<int> inb;
    set<int> inc;

    long long suma = 0, sumb = 0, sumc = 0;

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

        if (i < na) {
            where[i] = 0;
            ina.insert(i);
            suma += x[i];
            lina.push_back(i);
        } else if (i < na + nb) {
            where[i] = 1;
            inb.insert(i);
            sumb += x[i];
            linb.push_back(i);
        } else {
            where[i] = 2;
            inc.insert(i);
            sumc += x[i];
            linc.push_back(i);
        }
    }

    auto find_rand_in = [&](vector<int> &inx, set<int> &linx) {
        while (true) {
            int pos = rand()%inx.size();
            if (linx.count(inx[pos]) == 0) {
                swap(inx[pos], inx[inx.size() - 1]);
                inx.pop_back();
            } else {
                return inx[pos];
            }
        }
    };

    int stop_time = start + 5 * n ;
    while (clock() < stop_time) {
        if (suma + sumb > sumc && suma + sumc > sumb && sumb + sumc > suma) {
            cout << "YES\n";
            for (auto &y : ina) {
                cout << x[y] << ' ';
            }
            cout << '\n';
            for (auto &y : inb) {
                cout << x[y] << ' ';
            }
            cout << '\n';
            for (auto &y : inc) {
                cout << x[y] << ' ';
            }
            cout << '\n';
            
            return;
        }

        if (suma + sumb <= sumc) {
            // Scot din c
            auto rmc = find_rand_in(linc, inc);
            if (rand() & 1) {
                auto rma = find_rand_in(lina, ina);
                ina.erase(rma);
                inc.erase(rmc);
                sumc -= x[rmc];
                suma -= x[rma];
                suma += x[rmc];
                sumc += x[rma];
                ina.insert(rmc);
                inc.insert(rma);
                lina.push_back(rmc);
                linc.push_back(rma);
            } else {
                auto rmb = find_rand_in(linb, inb);
                inb.erase(rmb);
                inc.erase(rmc);
                sumc -= x[rmc];
                sumb -= x[rmb];
                sumb += x[rmc];
                sumc += x[rmb];
                inb.insert(rmc);
                inc.insert(rmb);
                linb.push_back(rmc);
                linc.push_back(rmb);
            }
        } else if(suma + sumc <= sumb) {
            auto rmb = find_rand_in(linb, inb);
            if (rand() & 1) {
                auto rma = find_rand_in(lina, ina);
                ina.erase(rma);
                inb.erase(rmb);
                sumb -= x[rmb];
                suma -= x[rma];
                suma += x[rmb];
                sumb += x[rma];
                ina.insert(rmb);
                inb.insert(rma);
                lina.push_back(rmb);
                linb.push_back(rma);
            } else {
                auto rmc = find_rand_in(linc, inc);
                inc.erase(rmc);
                inb.erase(rmb);
                sumb -= x[rmb];
                sumc -= x[rmc];
                sumc += x[rmb];
                sumb += x[rmc];
                inc.insert(rmb);
                inb.insert(rmc);
                linb.push_back(rmc);
                linc.push_back(rmb);
            }
        } else {
            auto rma = find_rand_in(lina, ina);
            if (rand() & 1) {
                auto rmb = find_rand_in(linb, inb);
                ina.erase(rma);
                inb.erase(rmb);
                sumb -= x[rmb];
                suma -= x[rma];
                suma += x[rmb];
                sumb += x[rma];
                ina.insert(rmb);
                inb.insert(rma);
                lina.push_back(rmb);
                linb.push_back(rma);
            } else {
                auto rmc = find_rand_in(linc, inc);
                ina.erase(rma);
                inc.erase(rmc);
                sumc -= x[rmc];
                suma -= x[rma];
                suma += x[rmc];
                sumc += x[rma];
                ina.insert(rmc);
                inc.insert(rma);
                lina.push_back(rmc);
                linc.push_back(rma);
            }
        }
    }

    cout << "NO\n";
    return;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    srand(time(NULL));

    int t;
    cin >> t;

    while(t--) {
        solve();
    }

    return 0;
}