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

const int N = 3e5 + 1, B = 501;
int n, m, dep[N], in[N], out[N], dfs_tot;
vector<int> adj[N];
struct ask
{
    int opt, a, x, y, z;
} b[N];
void dfs(int cur, int fa)
{
    dep[cur] = dep[fa] + 1;
    in[cur] = ++dfs_tot;
    for (int i : adj[cur])
        dfs(i, cur);
    out[cur] = dfs_tot;
}

int bfs_order[N], bfs_tot, tim[N];
vector<pair<int, int>> node[N];
void bfs()
{
    queue<int> que;
    que.push(1);
    bfs_tot = bfs_order[1] = tim[1] = 1;
    while (!que.empty())
    {
        int cur = que.front();
        que.pop();
        for (int i : adj[cur])
        {
            bfs_order[i] = ++bfs_tot;
            tim[bfs_tot] = i;
            que.push(i);
        }
    }
}

struct BIT
{
    int bit[N];
    int lowbit(int x)
    {
        return x & -x;
    }
    void add(int x, int y)
    {
        while (x <= n)
        {
            bit[x] += y;
            x += lowbit(x);
        }
    }
    int query(int x)
    {
        int res = 0;
        while (x)
        {
            res += bit[x];
            x -= lowbit(x);
        }
        return res;
    }
} tr[B];

int ans[N];
void solve()
{
    cin >> n >> m;
    for (int i = 2, x; i <= n; i++)
    {
        cin >> x;
        adj[x].push_back(i);
    }
    for (int i = 1; i <= m; i++)
    {
        cin >> b[i].opt >> b[i].a;
        if (b[i].opt == 1)
            cin >> b[i].x >> b[i].y >> b[i].z;
    }
    dfs(1, 0);
    for (int c = 1; c <= 500; c++)
    {
        for (int i = 1; i <= m; i++)
        {
            auto &[opt, a, x, y, z] = b[i];
            if (opt == 1 and x == c)
                tr[(dep[a] + y) % c].add(in[a], z), tr[(dep[a] + y) % c].add(out[a] + 1, -z);
            else if (opt == 2)
                ans[i] += tr[dep[a] % c].query(in[a]);
        }
        for (int i = 1; i <= m; i++)
        {
            auto &[opt, a, x, y, z] = b[i];
            if (opt == 1 and x == c)
                tr[(dep[a] + y) % c].add(in[a], -z), tr[(dep[a] + y) % c].add(out[a] + 1, z);
        }
    }

    bfs();
    for (int i = 1; i <= n; i++)
        node[dep[i]].push_back({in[i], bfs_order[i]});
    for (int i = 1; i <= n; i++)
    {
        auto &t = node[i];
        sort(t.begin(), t.end());
    }
    for (int i = 1; i <= m; i++)
    {
        auto &[opt, a, x, y, z] = b[i];
        if (opt == 1 and x <= 500)
            continue;
        if (opt == 1)
        {
            int cur = dep[a] + y;
            while (cur <= n)
            {
                auto &t = node[cur];
                auto it1 = lower_bound(t.begin(), t.end(), pair<int, int>{in[a], 0});
                auto it2 = lower_bound(t.begin(), t.end(), pair<int, int>{out[a] + 1, 0});
                if (it1 != it2)
                {
                    int l = it1->second, r = l + (it2 - it1) - 1;
                    tr[0].add(l, z), tr[0].add(r + 1, -z);
                }
                cur += x;
            }
        }
        else
            ans[i] += tr[0].query(tim[a]);
    }

    for (int i = 1; i <= m; i++)
        if (b[i].opt == 2)
            cout << ans[i] << '\n';

    memset(tr[0].bit, 0, sizeof(tr[0].bit));
    memset(ans, 0, sizeof(ans));
    for (int i = 1; i <= n; i++)
    {
        adj[i].clear();
        node[i].clear();
    }
    bfs_tot = dfs_tot = 0;
}
signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int t;
    cin >> t;
    while (t--)
        solve();
}
/*
1
5 5
1 1 2 1
1 1 5 4 1
1 1 4 1 5
1 2 1 0 4
2 3
2 1
*/