#include <stdio.h>
#include <atcoder/all>
#include <bits/stdc++.h>
using namespace std;
using namespace atcoder;
using mint = modint998244353;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define Inf32 1000000001
#define Inf64 4000000000000000001

struct HLD{
	vector<int> sz,parent,depth,root,pos;
	vector<int> arr;
	HLD(vector<vector<int>> &E){
		sz.resize(E.size(),1);
		parent.resize(E.size(),0);
		depth.resize(E.size(),0);
		root.resize(E.size(),0);
		pos.resize(E.size(),0);
		
		dfs(0,-1,E);
		dfs2(0,-1,E,0);
	}
	
	void dfs(int now,int p,vector<vector<int>> &E){
		parent[now] = p;
		if(p==-1){
			depth[now] = 0;
		}
		else{
			depth[now] = depth[p]+1;
		}
		for(int i=0;i<E[now].size();i++){
			int to = E[now][i];
			if(to==p)continue;
			dfs(to,now,E);
			sz[now] += sz[to];
		}
	}
	
	void dfs2(int now,int p,vector<vector<int>> &E,int r){
		pos[now] = arr.size();
		arr.push_back(now);
		root[now] = r;
		int maxi = 0;
		int ind = -1;
		for(int i=0;i<E[now].size();i++){
			int to = E[now][i];
			if(to==p)continue;
			if(maxi<sz[to]){
				maxi = sz[to];
				ind = to;
			}
		}
		if(ind==-1)return;
		dfs2(ind,now,E,r);
		for(int i=0;i<E[now].size();i++){
			int to = E[now][i];
			if(to==p||to==ind)continue;
			dfs2(to,now,E,to);
		}
	}
	
	vector<pair<int,int>> query(int u,int v){
		vector<pair<int,int>> ret;
		int t = 0;
		while(root[u]!=root[v]){
			if(depth[root[u]] <= depth[root[v]]){
				ret.insert(ret.begin()+t,{pos[root[v]], pos[v]});
				v = parent[root[v]];
			}
			else{
				ret.insert(ret.begin()+t,{pos[u],pos[root[u]]});
				u = parent[root[u]];
				t++;
			}
		}
		ret.insert(ret.begin()+t,{pos[u],pos[v]});
		return ret;
	}
	
	int lca(int u,int v){
		for(;;v=parent[root[v]]){
			if(pos[u]>pos[v])swap(u,v);
			if(root[u]==root[v])return u;
		}
	}
	
	int get_distance(int u,int v){
		return depth[u] + depth[v] - 2 * depth[lca(u,v)];
	}
	
};

vector<array<long long,3>> t;
void dfs(int cv,int pv,auto &E){
	//cout<<cv<<endl;
	t[cv][0] = 1;
	t[cv][1] = 0;
	if(cv==0)t[cv][2] = Inf64;
	rep(i,E[cv].size()){
		int to = E[cv][i].first;
		if(pv==to)continue;
		//cout<<cv<<','<<pv<<','<<to<<endl;
		long long c = E[cv][i].second;
		t[to][2] = c;
		dfs(to,cv,E);
		t[cv][0] += t[to][0];
	}
	
}

array<long long,3> op(array<long long,3> a,array<long long,3> b){
	array<long long,3> ret;
	rep(i,3)ret[i]=  min(a[i],b[i]);
	return ret;
}

array<long long,3> e(){
	array<long long,3> ret;
	rep(i,3)ret[i] = Inf64;
	return ret;
}

array<long long,3> mapping(array<long long,3> a,array<long long,3> b){
	rep(i,3)a[i] += b[i];
	return a;
}

array<long long,3> composition(array<long long,3> a,array<long long,3> b){
	return mapping(a,b);
}

array<long long,3> id(){
	array<long long,3> ret;
	rep(i,3)ret[i] = 0;
	return ret;
}

bool F(array<long long,3> a){
	return a[2]>0;
}

int main(){
	int n,q;
	cin>>n>>q;
	
	vector<vector<pair<int,long long>>> E(n);
	vector<vector<int>> es(n);
	rep(i,n-1){
		long long a,b,c;
		cin>>a>>b>>c;
		a--,b--;
		E[a].emplace_back(b,c);
		E[b].emplace_back(a,c);
		es[a].push_back(b);
		es[b].push_back(a);
	}
	t.resize(n);
	dfs(0,-1,E);
	//cout<<'a'<<endl;
	HLD H(es);
	{
		vector<array<long long,3>> ta(n);
		rep(i,n){
			ta[H.pos[i]] = t[i];
		}
		swap(ta,t);
	}
	lazy_segtree<array<long long,3>,op,e,array<long long,3>,mapping,composition,id> seg(t);
	//cout<<'b'<<endl;
	rep(_,q){
		int type;
		cin>>type;
		if(type==1){
			int v;
			long long x;
			cin>>v>>x;
			v--;
			auto ret = H.query(v,0);
			array<long long,3> tt;
			tt[0] = 0;
			tt[1] = x;
			tt[2] = -x;
			rep(i,ret.size()){
				int ll = ret[i].first,rr = ret[i].second;
				if(ll>rr)swap(ll,rr);
				rr++;
				seg.apply(ll,rr,tt);
			}
			if(seg.all_prod()[2]<=0){
				int target;
				rep(i,ret.size()){
					int ll = ret[i].first,rr = ret[i].second;
					if(ll>rr)swap(ll,rr);
					rr++;
					if(seg.prod(ll,rr)[2]>0)continue;
					
					ll = ret[i].first,rr = ret[i].second;
					if(ll<rr){
						rr++;
						int tr = seg.max_right<F>(ll);
						target = H.arr[tr];
						break;
					}
					else{
						swap(ll,rr);
						rr++;
						int tl = seg.min_left<F>(rr);
						target = H.arr[tl-1];
						break;
					}
					
					break;
				}
				//cout<<seg.get(H.pos[3])[2]<<endl;
				//cout<<"hoge"<<target<<endl;
				ret = H.query(target,0);
				auto temp = seg.get(H.pos[target]);
				tt[0] = -temp[0];
				tt[1] = -temp[1];
				tt[2] = temp[1];
				//cout<<target<<' '<<tt[2]<<endl;
				rep(i,ret.size()){
					int ll = ret[i].first,rr = ret[i].second;
					if(ll>rr)swap(ll,rr);
					rr++;
					seg.apply(ll,rr,tt);
				}
				seg.set(H.pos[target],e());
			}
		}
		else{
			cout<<seg.get(H.pos[0])[0]<<endl;
		}
		
	}
	
	return 0;
}