#include <bits/stdc++.h>

#define rep(i, s, n) for (int i = int(s); i < int(n); i++)
#define rrep(i, s, n) for (int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ull = unsigned long long;
using ld = long double;

template <class T> bool chmin(T &a, T b) {
    if (a <= b) return false;
    a = b;
    return true;
}

template <class T> bool chmax(T &a, T b) {
    if (a >= b) return false;
    a = b;
    return true;
}

using namespace std;

template <ll m> struct modint {
    using mint = modint;
    ll a;
    modint(ll x = 0) : a((x % m + m) % m) {}

    static constexpr ll mod() {
        return m;
    }

    ll val() const {
        return a;
    }

    ll &val() {
        return a;
    }

    mint pow(ll n) const {
        mint res = 1;
        mint x = a;
        while (n) {
            if (n & 1) res *= x;
            x *= x;
            n >>= 1;
        }
        return res;
    }

    mint inv() const {
        return pow(m - 2);
    }

    mint operator+=(const mint rhs) {
        a += rhs.a;
        if (a >= m) a -= m;
        return *this;
    }

    mint operator-=(const mint rhs) {
        if (a < rhs.a) a += m;
        a -= rhs.a;
        return *this;
    }

    mint operator*=(const mint rhs) {
        a = a * rhs.a % m;
        return *this;
    }

    mint operator/=(const mint rhs) {
        *this *= rhs.inv();
        return *this;
    }
    friend mint operator+(const mint &lhs, const mint &rhs) {
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint &lhs, const mint &rhs) {
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint &lhs, const mint &rhs) {
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint &lhs, const mint &rhs) {
        return mint(lhs) /= rhs;
    }
    friend bool operator==(const mint &lhs, const mint &rhs) {
        return lhs.a == rhs.a;
    }
    friend bool operator!=(const mint &lhs, const mint &rhs) {
        return !(lhs == rhs);
    }
    mint operator+() const {
        return *this;
    }
    mint operator-() const {
        return mint() - *this;
    }
};

using mint = modint<1'000'000'007>;

template <typename T> struct Binom {
    Binom(int lim = 600'000) {
        if (kaijo.empty()) {
            kaijo = {1, 1};
            kainv = {1, 1};
        }
        kaijo.resize(lim + 1), kainv.resize(lim + 1);
        for (int i = 2; i <= lim; i++) kaijo[i] = kaijo[i - 1] * T(i);
        kainv[lim] = kaijo[lim].inv();
        for (int i = lim - 1; i >= 2; i--) kainv[i] = kainv[i + 1] * T(i + 1);
    }
    static T fact(int x) {
        if (x < 0) return T(0);
        return kaijo[x];
    }
    static T ifact(int x) {
        if (x < 0) return T(0);
        return kainv[x];
    }
    static T C(int n, int r) {
        if (n < 0 || n < r || r < 0) return T(0);
        return kaijo[n] * kainv[r] * kainv[n - r];
    }
    static T P(int n, int r) {
        if (n < 0 || n < r || r < 0) return T(0);
        return kaijo[n] * kainv[n - r];
    }
    static T Inv(int n) {
        assert(0 < n);
        return ifact(n) * fact(n - 1);
    }
    T operator()(int n, int r) {
        return C(n, r);
    }

  private:
    static vector<T> kaijo, kainv;
};

template <typename T> vector<T> Binom<T>::kaijo = vector<T>(2, T(1));
template <typename T> vector<T> Binom<T>::kainv = vector<T>(2, T(1));

void solve() {
    int n;
    std::cin >> n;
    std::vector<ll> a(n), b(n), w(n);
    rep(i,0,n) {
        std::cin >> a[i];
    }
    rep(i,0,n) {
        std::cin >> b[i];
        b[i]--;
    }
    rep(i,0,n) {
        std::cin >> w[i];
    }
    Binom<mint> binom;
    std::vector<mint> ans(n);
    std::vector<int> nxt(n, -1);
    std::vector rev(n, std::vector<int>());
    std::vector<int> seen(n, -1);
    rep(i,0,n) {
        ans[i] = a[i];
        if(i == b[i]) {
            seen[i] = 0;
        }
        else if(a[i] < a[b[i]]) {
            seen[i] = 1;
        }
        else if(a[b[i]] + w[b[i]] <= a[i]) {
            seen[i] = 0;
        }
        else {
            nxt[i] = b[i];
            rev[b[i]].emplace_back(i);
        }
    }
    std::queue<int> que;
    std::vector<int> dp(n, 0);
    rep(i,0,n) {
        if(seen[i] == 1) {
            dp[i] = 1;
            que.push(i);
        }
    }
    while(!que.empty()) {
        int v = que.front();
        que.pop();
        ans[v] += mint(w[v]) * binom.C(n, dp[v]) * binom.fact(n - dp[v]) * binom.ifact(n);
        for(auto nv: rev[v]) {
            dp[nv] = dp[v] + 1;
            que.push(nv);
        }
    }
    rep(i,0,n) {
        std::cout << ans[i].val() << " \n"[i == n-1];
    }
}

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);
    int t;
    std::cin >> t;
    while(t--) {
        solve();
    }
}