F

#include <bits/stdc++.h>

using namespace std;

#define ll     long long
#define _test   int _TEST; cin>>_TEST; while(_TEST--)
#define pb     push_back

class _sTTs_
{
    public:
    const int N = 5e5+10;int n;ll int *lk, *kl;
    _sTTs_()
    {lk = new ll int[4*N]; kl = new ll int[4*N]; }

    void init(vector<ll int> &_c, int n)
    {this->n = n;___lk(_c, n);}

    void g(int v, int l, int r)
    {
        if (kl[v]==0)return;
        if (kl[v]!=0)
        {lk[v]+=(r-l+1)*kl[v];
            if (l!=r)
            {kl[v<<1]+=kl[v];kl[v<<1|1]+=kl[v];}
        }kl[v]=0;
    }

    void __(int v, int l, int r, vector<ll int> &_c)
    {
        kl[v]=0;if (l==r)
        {lk[v]=_c[l];return;}
        int m=(l+r)>>1;
        __(v<<1,l,m, _c);__(v<<1|1,m+1,r, _c);
        lk[v]=lk[v<<1]+lk[v<<1|1];
    }

    void _(int v, int l, int r, int ss, int se, ll int _v)
    {
        g(v,l,r);if (ss>se)return;
        if (l==ss && r==se)
        { lk[v]+=_v*(r-l+1); if (l!=r)
            { kl[v<<1]+=_v; kl[v<<1|1]+=_v; }
            return;
        }
        int m=(l+r)>>1; _(v<<1,l,m,ss,min(se,m),_v);  _(v<<1|1,m+1,r,max(m+1,ss),se,_v);
        lk[v]=lk[v<<1]+lk[v<<1|1];
    }

    ll int s(int v, int l, int r, int ss, int se)
    { g(v,l,r);
        if (ss>se) return 0;
        if (l==ss && r == se) return lk[v];
        int m=(l+r)>>1;
        return s(v<<1,l,m,ss,min(se,m)) + s(v<<1|1,m+1,r,max(m+1,ss),se);
    }

    void ___lk(vector<ll int> &_c, ll int n)
    { __(1, 0, n-1, _c); }

    void _Range(int l, int r, ll int _v)
    {  _(1,0,n-1,l,r,_v); }

    ll int _GG(int l, int r)
    { return s(1,0,n-1,l,r); }
};

int main()
{
    _sTTs_ sgt;
    _sTTs_ sgt2;

    _test
    {
        int n;
        cin>>n;

        vector<vector<int>> tree(n+10);
        int sz = 1;
        vector<int> verAdd(n+10);
        vector<vector<pair<int, ll int>>> valAdded(n+5);

        for(int q=0, t, v, x; q<n; q++)
        {
            cin>>t;

            if(t == 1)
            {
                cin>>v;
                tree[v].pb(++sz);
                verAdd[sz] = q+1;
            }
            else
            {
                cin>>v>>x;
                valAdded[v].pb({q+1, x});
            }
        }

        vector<int> st(n+10), en(n+10);
        int tm = 1;

        function<void(int)> DFS = [&](int u)
        {
            st[u] = en[u] = tm++;

            for(auto v: tree[u])
            {
                DFS(v);
                en[u] = max(en[u], en[v]);
            }
        };

        DFS(1);

        vector<ll int> ans(n+10);
        sgt.init(ans, n+10);
        sgt2.init(ans, n+10);

        function<void(int)> DFS2 = [&](int u)
        {
            for(auto [t, x]: valAdded[u])
            {
                sgt._Range(st[u], en[u], x);
                sgt2._Range(t, t, x);
            }

            ans[u] = sgt._GG(st[u], st[u]);

            if(u > 1)
                ans[u] -= sgt2._GG(0, verAdd[u]-1);

            for(auto v: tree[u])
                DFS2(v);

            for(auto [t, x]: valAdded[u])
                sgt2._Range(t, t, -x);
        };

        DFS2(1);

        for(int i=1; i<=sz; i++)
            cout<<ans[i]<<" ";
        cout<<"\n";
    }
}