#pragma GCC optimize("O3")
// #pragma GCC target("avx512vl,avx512dq,avx512bw")
#pragma GCC target("avx2")
#include <cassert>
#include <iostream>
void* operator new(size_t s) {
    constexpr static int MEM = 1e8;
    static char data[MEM];
    static size_t ptr = 0;
    ptr += s;
    assert(ptr <= MEM);
    return data + ptr - s;
}

void operator delete(void*) { ; }
#include <bits/stdc++.h>

std::mt19937 rnd;

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> x(n), h(n), v(n);
    for (int i = 0; i < n; i++) {
        std::cin >> x[i];
    }
    for (int i = 0; i < n; i++) {
        std::cin >> h[i];
    }
    for (int i = 0; i < n; i++) {
        std::cin >> v[i];
    }
    std::vector<int> s;
    for (int i = 0; i < n; i++) {
        if (h[i] == 0) {
            s.push_back(v[i]);
        }
    }
    std::sort(s.begin(), s.end());
    for (int i = 0; i < n; i++) {
        int it = std::lower_bound(s.begin(), s.end(), v[i]) - s.begin();
        it += 5;
        v[i] = it;
        // if (h[i] == 0) {
        // } else {
        //     ;
        // }
    }

    if (n - std::accumulate(h.begin(), h.end(), 0) > n / 2) {
        assert(false);
        for (int i = 0; i < n; i++) {
            std::cout << -1 << " \n"[i == n - 1];
        }
        return;
    }

    int it = h.rend() - std::find(h.rbegin(), h.rend(), 0) - 1;
    if (it == -1) {
        assert(false);
        for (int i = 0; i < n; i++) {
            std::cout << x[i] << " \n"[i == n - 1];
        }
        return;
    }

    std::vector<int> ans(n, -1);
    std::vector<uint16_t> cum, fuck;
    for (int i = 0; i <= it; i++) {
        if (h[i] == 0) {
            cum.push_back(v[i]);
        } else {
            fuck.push_back(v[i]);
        }
    }
    while (it < n && cum.size() > fuck.size()) {
        fuck.push_back(v[it]);
        it++;
    }
    std::sort(fuck.begin(), fuck.end());
    std::sort(cum.begin(), cum.end());

    int x_left = -1;
    int left = 0;
    std::multiset<int> set;
    for (int i = it; i < n; i++) {
        if (h[i] == 1) {
            auto it = std::lower_bound(fuck.begin(), fuck.end(), v[i]);
            fuck.insert(it, v[i]);
        }

        auto check = [&]() {
            if (fuck.size() >= cum.size()) {
                uint16_t cnt = 0;
                for (int i = 0; i < 100; i++) {
                    int id = rnd() % cum.size();
                    if (fuck[id] > cum[id]) {
                        return false;
                    }
                }
                constexpr int G = 1 << 10;
                if (1) {
#pragma GCC ivdep
                    for (int i = 0; i < cum.size(); i++) {
                        cnt += fuck[i] > cum[i];
                        if (i + G < cum.size()) {
#pragma GCC ivdep
                            for (int j = 0; j < G; j++) {
                                cnt += fuck[i + j] > cum[i + j];
                            }
                            if (cnt > 0) {
                                break;
                            }
                            i += G - 1;
                        }
                    }
                } else {
#pragma GCC ivdep
                    for (int i = cum.size() - 1; i >= 0; i--) {
                        cnt += fuck[i] > cum[i];
                        if (i > G) {
#pragma GCC ivdep
                            for (int j = 0; j < G; j++) {
                                cnt += fuck[i - j] > cum[i - j];
                            }
                            if (cnt > 0) {
                                break;
                            }
                            i -= G - 1;
                        }
                    }
                }
                return cnt == 0;
            }
            return false;
        };

        if (x_left != left && fuck.size() >= cum.size() && check()) {
            x_left = left;
        }

        while (x_left == left && fuck.size() >= cum.size() && left < i) {
            if (h[left] == 0) {
                set.insert(v[left]);
                left++;
                x_left++;
                continue;
            }
            int val_ch = v[left];
            int it = std::lower_bound(fuck.begin(), fuck.end(), val_ch) - fuck.begin();
            fuck.erase(fuck.begin() + it);
            left++;

            // std::pair<int, int> min(1.1e9, -1);
            // for (int i = 0; i < left; i++) {
            //     if (h[i] == 0 && v[i] >= val_ch) {
            //         min = std::min(min, {v[i], i});
            //     }
            // }
            auto it1 = set.lower_bound(val_ch);

            if (it1 == set.end()) {
                if (it >= cum.size()) {
                    x_left = left;
                    continue;
                }
                if (check()) {
                    x_left = left;
                    continue;
                }
                break;
            } else {
                // v[min.second] = -1;
                auto it = std::lower_bound(cum.begin(), cum.end(), *it1);
                cum.erase(it);
                set.erase(it1);

                x_left = left;
            }
        }

        if (x_left != -1) {
            ans[i] = x[i] * 2 - x[x_left];
        }
    }
    for (int i = 0; i < n; i++) {
        std::cout << ans[i] << " \n"[i == n - 1];
    }
}

int32_t main() {
    std::ios_base::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int t;
    std::cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}