#include <iostream>
#include <vector>
#include <vector>
#include <set>
#include "map"
#include <array>
#include <algorithm>
#include <random>
#include <bitset>
#include <chrono>
using namespace std;
#define all(x)x.begin(),x.end()
#define pack(x)sort(all(x));x.erase(unique(all(x)),x.end())
#define gi(x,v)lower_bound(all(x),v)-x.begin()
using ll=long long;
using ld=long double;
using tu=array<ll,5>;
vector<int> v[300'010];
const int sq=550;
struct seg{
    int* tree;
    int N;
    void init(int n){
        N=n;
        if(N==0)return;
        tree=new int[N+1];
    }void clear(){
        if(N==0)return;
        N=0;
        delete[] tree;
    }
    
    int query(int i) {
        i++;
        int sum = 0;
        while (i > 0) {
            sum += tree[i];
            i -= i&-i;
        }
        return sum;
    }void update(int i, ll diff) {
        while (i <= N) {
            tree[i] += diff;
            i += i&-i;
        }
    }
    
    void update(int i, int j, int diff) {
        i++;j++;
        update(i, diff);
        update(j+1, -diff);
    }
}dep[300'010];
vector<seg> line[sq+10];
///node = y mod x
vector<vector<int>> vl[sq+10];
vector<int> vd[300'010];
int deps[300'010];
int in[300'010],out[300'010],pv;
int D;
void dfs(int n,int p,int d){
    in[n]=++pv;
    deps[n]=d;D=max(D,d+1);
    vd[d].push_back(pv);
    for(auto i:v[n]){
        if(i==p)continue;
        dfs(i,n,d+1);
    }out[n]=pv;
}
vector<tu> quer;
void solve(){
    int n,m;quer.clear();
    cin>>n>>m;
    D=0;
    int a,b,c,d,f;
    for(int i=2;i<=n;i++){
        cin>>a;
        v[a].push_back(i);
    }
    pv=0;
    dfs(1,0,1);
    
    for(int j=0;j<m;j++){
        cin>>a>>b;
        if(a==1){
            int s=in[b];
            int e=out[b];
            cin>>c>>d>>f;
            quer.push_back({a,b,c,d,f});
            if(c<=sq){
                d+=deps[b];
                d%=c;
                vl[c][d].push_back(s);
                vl[c][d].push_back(e+1);
            }
        }else{
            quer.push_back({a,b});
        }
    }
    for(int i=1;i<=sq;i++){
        for(int j=0;j<i;j++){
vl[i][j].push_back(1);
vl[i][j].push_back(n+2);
            if(vl[i][j].empty())continue;
            line[i][j].init(vl[i][j].size());
            pack(vl[i][j]);////정렬 - 해결
        }
    }for(int i=1;i<=D;i++){
        dep[i].init(vd[i].size());
    }
    for(int j=0;j<m;j++){
        a=quer[j][0];
        b=quer[j][1];
        c=quer[j][2];
        d=quer[j][3];
        f=quer[j][4];
        if(a==1){
            int s=in[b];
            int e=out[b];
            ///node = d mod c -> add f
            if(c<=sq){
                d+=deps[b];
                d%=c;
                int sv=gi(vl[c][d],s);
                int ev=gi(vl[c][d],e+1)-1;
                line[c][d].update(sv,ev,f);
            }else{
                for(int i=deps[b]+d;i<=D;i+=c){
                    int sv=gi(vd[i],s);
                    int ev=gi(vd[i],e+1)-1;
                    dep[i].update(sv,ev,f);
                }
            }
        }else{
            int dx=deps[b];
            int idx=in[b];
            int ans=dep[dx].query(gi(vd[dx],idx));
            for(int i=1;i<=sq;i++){
                int p=dx%i;
                ans+=line[i][p].query(gi(vl[i][p],idx+1)-1);
            }cout<<ans<<'\n';
        }
    }
    
    
    for(int i=1;i<=sq;i++){
        for(int j=0;j<i;j++){
            line[i][j].clear();
            vl[i][j].clear();
            vl[i][j].shrink_to_fit();
        }
    }
    for(int i=1;i<=n;i++){
        dep[i].clear();
        vd[i].clear();
        vd[i].shrink_to_fit();
        v[i].clear();
        v[i].shrink_to_fit();
    }
}
int main(){
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int tc;
    cin>>tc;
    for(int i=1;i<=sq;i++){
        line[i].resize(i);
        line[i].shrink_to_fit();
        vl[i].resize(i);
        vl[i].shrink_to_fit();
    }
    while(tc--){
        solve();
    }
 
}