#include <bits/stdc++.h>
using namespace std;

#define mod_n 1000000007
#define mod(x) ((x) % mod_n)
#define int int64_t
#define max_len 500010

int qpow(int x, int n)
{
    if (n == 0)
        return 1;
    else if (n == 1)
        return mod(x);
    else if (n % 2 == 0)
        return qpow(mod(x * x), n / 2);
    else
        return mod(qpow(mod(x * x), n / 2) * x);
}

int inv(int x)
{
    return qpow(x, mod_n - 2);
}

int inv_jc_arr[max_len];
void init_inv_jc()
{
    inv_jc_arr[0] = inv_jc_arr[1] = 1;
    for (int i = 2; i < max_len; i++)
    {
        inv_jc_arr[i] = mod(inv_jc_arr[i - 1] * inv(i));
    }
}

struct node
{
    int p_next;
    int have_sugar;
    int will_add;

    int E_val;
    int len;

    bool dfs1_vis;
    bool dfs2_vis;
    bool duan;
    int change_E;
} node_arr[max_len];

int in_stack[max_len];
vector<int> stk_vec;

void dfs1(int now_i)
{
    node_arr[now_i].dfs1_vis = true;
    if (in_stack[now_i] == 0)
    {
        in_stack[now_i] = stk_vec.size();
        stk_vec.push_back(now_i);

        dfs1(node_arr[now_i].p_next);

        stk_vec.pop_back();
        in_stack[now_i] = 0;
    }
    else // huan
    {
        int huan_len = stk_vec.size() - in_stack[now_i];
        int base_len = in_stack[now_i];
        for (int i = 0; i < huan_len; i++)
        {
            int ni = stk_vec[base_len + (huan_len + i) % huan_len];
            int ni_nx = node_arr[ni].p_next;

            if (node_arr[ni].have_sugar < node_arr[ni_nx].have_sugar)
            {
                node_arr[ni].change_E = 1;
                node_arr[ni].duan = true;
                node_arr[ni].p_next = ni;
                // break;
            }
            else if (node_arr[ni].have_sugar >= node_arr[ni_nx].have_sugar +
                                                    node_arr[ni_nx].will_add)
            {

                node_arr[ni].change_E = 0;
                node_arr[ni].p_next = ni;
                // break;
            }
        }
    }
}

int dfs2(int now_i)
{
    node_arr[now_i].dfs2_vis = true;
    if (node_arr[now_i].len != -1)
    {
        return node_arr[now_i].len;
    }
    if (node_arr[now_i].p_next == now_i)
    {
        node_arr[now_i].E_val = node_arr[now_i].have_sugar;
        if (node_arr[now_i].duan == true)
        {
            node_arr[now_i].change_E = 1;
            node_arr[now_i].E_val += node_arr[now_i].will_add;
        }
        node_arr[now_i].E_val = mod(node_arr[now_i].E_val);
        node_arr[now_i].len = 0;
        return 0;
    }
    else
    {
        int len = dfs2(node_arr[now_i].p_next);
        int pnx = node_arr[now_i].p_next;
        node_arr[now_i].E_val = node_arr[now_i].have_sugar;
        if (node_arr[now_i].have_sugar >= node_arr[pnx].have_sugar)
        {
            if (node_arr[now_i].have_sugar < node_arr[pnx].have_sugar +
                                                 node_arr[pnx].will_add)
            {
                node_arr[now_i].change_E = mod(inv(len + 2) * node_arr[pnx].change_E);
                node_arr[now_i].E_val +=
                    mod(node_arr[now_i].will_add * node_arr[now_i].change_E);

                node_arr[now_i].E_val = mod(node_arr[now_i].E_val);

                len = len + 1;
            }
            else
            {
                node_arr[now_i].change_E = 0;
                len = 0;
            }
        }
        else
        {
            node_arr[now_i].change_E = 1;
            node_arr[now_i].E_val += node_arr[now_i].will_add;
            node_arr[now_i].E_val = mod(node_arr[now_i].E_val);
            len = 0;
        }
        node_arr[now_i].len = len;
        return len;
    }
}

void init_arr(int N)
{
    for (int i = 0; i < N + 10; i++)
    {
        node_arr[i].len = -1;
        node_arr[i].E_val = 0;
        node_arr[i].change_E = 0;

        node_arr[i].dfs1_vis = false;
        node_arr[i].dfs2_vis = false;
        node_arr[i].duan = false;
    }
}

void sol()
{
    int N;
    cin >> N;
    init_arr(N);

    for (int i = 1; i <= N; i++)
    {
        cin >> node_arr[i].have_sugar;
    }
    for (int i = 1; i <= N; i++)
    {
        cin >> node_arr[i].p_next;
    }
    for (int i = 1; i <= N; i++)
    {
        cin >> node_arr[i].will_add;
    }
    for (int i = 1; i <= N; i++)
    {
        if (node_arr[i].dfs1_vis == false)
        {
            dfs1(i);
        }
    }
    for (int i = 1; i <= N; i++)
    {
        if (node_arr[i].dfs2_vis == false)
        {
            dfs2(i);
        }
    }
    for (int i = 1; i <= N; i++)
    {
        cout << node_arr[i].E_val << (i == N ? '\n' : ' ');
    }
}

int32_t main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    init_inv_jc();
    int T;
    cin >> T;
    while (T--)
    {
        sol();
    }
}