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

namespace FastIO
{

class FastIOBase
{
 protected:
#ifdef OPENIOBUF
	static const int BUFSIZE=1<<16;
	char buf[BUFSIZE+1];
	int buf_p=0;
#endif
	FILE *target;
	FastIOBase(FILE *f): target(f){}
	~FastIOBase()=default;
 public:
#ifdef OPENIOBUF
	virtual void flush()=0;
#endif
};

class FastOutput final: public FastIOBase
{
 private:
	void __putc(char x)
	{
#ifdef OPENIOBUF
		if(buf[buf_p++]=x,buf_p==BUFSIZE) flush();
#else
		putc(x,target);
#endif
	}
	template<typename T>
	void __write(T x)
	{
		char stk[64],*top=stk;
		if(x<0) return __putc('-'),__write(-x);
		do *(top++)=x%10,x/=10; while(x);
		for(;top!=stk;__putc(*(--top)+'0'));
	}
 public:
	FastOutput(FILE *f=stdout): FastIOBase(f) {}
#ifdef OPENIOBUF
	~FastOutput() { flush(); }
	void flush() { fwrite(buf,1,buf_p,target),buf_p=0; }
#endif
	FastOutput &operator <<(char x)
	{ return __putc(x),*this; }
	FastOutput &operator <<(const char *s)
	{ for(;*s;__putc(*(s++)));return *this; }
	FastOutput &operator <<(const string &s)
	{ return (*this)<<s.c_str(); }
	template<typename T>
	enable_if_t<is_integral<T>::value,FastOutput&> operator <<(const T &x)
	{ return __write(x),*this; }
	template<typename ...T>
	void writesp(const T &...x)
	{ initializer_list<int>{(this->operator<<(x),__putc(' '),0)...}; }
	template<typename ...T>
	void writeln(const T &...x)
	{ initializer_list<int>{(this->operator<<(x),__putc('\n'),0)...}; }
	template<typename Iter>
	void writesp(Iter begin,Iter end)
	{ while(begin!=end) (*this)<<*(begin++)<<' '; }
	template<typename Iter>
	void writeln(Iter begin,Iter end)
	{ while(begin!=end) (*this)<<*(begin++)<<'\n'; }
}qout;

class FastInput final: public FastIOBase
{
 private:
	bool __eof;
 public:
	FastInput(FILE *f=stdin): FastIOBase(f),__eof(false)
#ifdef OPENIOBUF
	{ buf_p=BUFSIZE; }
	void flush() { buf[fread(buf,1,BUFSIZE,target)]=EOF,buf_p=0; }
	bool eof()const { return buf[buf_p]==EOF; }
#else
	{}
	bool eof()const { return feof(target); }
#endif
	char get()
	{
		if(__eof) return EOF;
#ifdef OPENIOBUF
		if(buf_p==BUFSIZE) flush();
		char ch=buf[buf_p++];
#else
		char ch=getc(target);
#endif
		return ~ch?ch:(__eof=true,EOF);
	}
	void unget(char c)
	{
		__eof=false;
#ifdef OPENIOBUF
		buf_p--;
#else
		ungetc(c,target);
#endif
	}
	explicit operator bool()const { return !__eof; }
	FastInput &operator >>(char &x)
	{ while(isspace(x=get()));return *this; }
	template<typename T>
	enable_if_t<is_integral<T>::value,FastInput&> operator >>(T &x)
	{
		char ch,sym=0;x=0;
		while(isspace(ch=get()));
		if(__eof) return *this;
		if(ch=='-') sym=1,ch=get();
		for(x=0;isdigit(ch);x=(x<<1)+(x<<3)+(ch^48),ch=get());
		return unget(ch),sym?x=-x:x,*this;
	}
	FastInput &operator >>(char *s)
	{
		while(isspace(*s=get()));
		if(__eof) return *this;
		for(;!isspace(*s) && !__eof;*(++s)=get());
		return unget(*s),*s='\0',*this;
	}
	FastInput &operator >>(string &s)
	{
		char str_buf[(1<<8)+1]={0},*p=str_buf;
		char *const buf_end=str_buf+(1<<8);
		while(isspace(*p=get()));
		if(__eof) return *this;
		for(s.clear(),p++;;p=str_buf)
		{
			for(;p!=buf_end && !isspace(*p=get()) && !__eof;p++);
			if(p!=buf_end) break;
			s.append(str_buf);
		}
		unget(*p),*p='\0',s.append(str_buf);
		return *this;
	}
	template<typename ...T>
	void read(T &...x)
	{ initializer_list<int>{(this->operator>>(x),0)...}; }
	template<typename Iter>
	void read(Iter begin,Iter end)
	{ while(begin!=end) (*this)>>*(begin++); }
}qin;

} // namespace FastIO
using FastIO::qin,FastIO::qout;

using LL=long long;
using LD=long double;
using UI=unsigned int;
using ULL=unsigned long long;

#ifndef DADALZY
#define FILEIO(file) freopen(file".in","r",stdin),freopen(file".out","w",stdout)
#define LOG(...) void()
#else
#define FILEIO(file)
#define LOG(...) fprintf(stderr,__VA_ARGS__)
#endif

int n,m,L[200005];
LL tmps[200005];
vector<pair<int,int>> g[200005];

class Fenk
{
 private:
	static constexpr int BW=9,B=(1<<BW);
	LL s1[200005],s2[10005];
 public:
	void build(LL *a)
	{
		LL lst=0;
		for(int i=1;i<=n;i++)
			if(i%B==0) s1[i]=a[i],s2[i>>BW]=(lst+=s1[i-1]);
			else s1[i]=s1[i-1]+a[i];
	}
	void add(int p,LL x)
	{
		int bi=p>>BW,br=min(n+1,(bi<<BW)+B),bn=n>>BW;
		for(int i=p;i<br;i++) s1[i]+=x;
		for(int i=bn;i>bi;i--) s2[i]+=x;
	}
	LL get(int p) { return s1[p]+s2[p>>BW]; }
}tr;

struct Cluster
{
	enum OP{ UNIT,RAKE,COMPRESS };
	OP op;
	int siz,u,v,lc,rc;
}t[400005];
int cnt,rt[200005],id[200005];
inline int rake(int x,int y)
{
	assert(t[x].u==t[y].u);
	t[++cnt]=Cluster{
		Cluster::RAKE,
		t[x].siz+t[y].siz,
		t[x].u,t[x].v,x,y
	};
	return cnt;
}
inline int compress(int x,int y)
{
	assert(t[x].v==t[y].u);
	t[++cnt]=Cluster{
		Cluster::COMPRESS,
		t[x].siz+t[y].siz,
		t[x].u,t[y].v,x,y
	};
	return cnt;
}
template<typename Iter,typename Func>
int build(Iter l,Iter r,Func &&mrg)
{
	if(l==r) return 0;
	if(r==l+1) return *l;
	int all=0,sum=0,mn=1e9;
	for(auto it=l;it!=r;it++) all+=t[*it].siz;
	Iter mid=l;
	for(auto it=l;it!=r;it++)
	{
		int tmp=abs(2*sum-all);
		if(tmp<mn) mn=tmp,mid=it;
		sum+=t[*it].siz;
	}
	int x=build(l,mid,mrg),y=build(mid,r,mrg);
	return mrg(x,y);
}

int siz[200005],dep[200005],anc[200005],son[200005];
int tot1,tot2,eul[400005],pos[200005],lb[200005],rb[200005],f[20][400005];
LL dis[200005];
void dfs1(int u,int fa=0)
{
	siz[u]=1,dep[u]=dep[fa]+1,anc[u]=fa;
	eul[pos[u]=++tot1]=u,lb[u]=++tot2;
	for(auto &[v,w]: g[u])
	{
		if(v==fa) continue;
		id[v]=w,t[w]=Cluster{Cluster::UNIT,1,u,v,0,0};
		dfs1(v,u),siz[u]+=siz[v];
		eul[++tot1]=u;
		if(siz[v]>siz[son[u]]) son[u]=v;
	}
	rb[u]=tot2;
}
void dfs2(int u,bool tp=true,int fa=0)
{
	if(son[u]) dfs2(son[u],false,u);
	for(auto &[v,w]: g[u])
		if(v!=fa && v!=son[u])
			dfs2(v,true,u);
	if(tp)
	{
		vector<int> vec;
		if(anc[u]) vec.push_back(id[u]);
		for(int i=son[u];i;i=son[i])
		{
			vector<int> tmp{id[i]};
			for(auto &[v,w]: g[anc[i]])
				if(v!=i && v!=anc[anc[i]])
					tmp.push_back(rt[v]);
			int x=build(tmp.begin(),tmp.end(),rake);
			vec.push_back(x);
		}
		rt[u]=build(vec.begin(),vec.end(),compress);
	}
}
inline bool cmpdep(int x,int y) { return dep[x]<dep[y]; }
void prework()
{
	for(int i=1;i<=tot1;i++) f[0][i]=eul[i];
	for(int i=1;(1<<i)<=tot1;i++)
		for(int j=1;j+(1<<i)-1<=tot1;j++)
			f[i][j]=min(f[i-1][j],f[i-1][j+(1<<(i-1))],cmpdep);
}
inline int lca(int u,int v)
{
	tie(u,v)=minmax(pos[u],pos[v]);
	int s=__lg(v-u+1);
	return min(f[s][u],f[s][v-(1<<s)+1],cmpdep);
}

int B,top[400005],tfa[400005],stt[200005];
vector<LL> blk,arr[400005][2];
void partition(int i,int tp=0,int fa=0,int d=0)
{
	if(!i) return;
	if(!tp && t[i].siz<=B) blk.push_back(i),tp=i;
	top[i]=tp,tfa[i]=fa;
	partition(t[i].lc,tp,i,d+1);
	partition(t[i].rc,tp,i,d+1);
}
template<typename Func>
void __dfsc(int u,int c,Func &&fn,LL d=0,int fa=0)
{
	fn(d);
	for(int i=stt[u];i<(int)g[u].size();i++)
	{
		auto &[v,w]=g[u][i];
		if(v==fa) continue;
		if(top[w]!=c) break;
		__dfsc(v,c,fn,d+L[w],u);
	}
}
template<typename Func>
void dfsCluster(int c,int u,Func &&fn)
{
	auto getstt=[&](int u)
	{
		stt[u]=lower_bound(
			g[u].begin(),g[u].end(),make_pair(0,c),
			[](auto &x,auto &y){ return top[x.second]<top[y.second]; }
		)-g[u].begin();
	};
	getstt(t[c].u),getstt(t[c].v);
	__dfsc(u,c,forward<Func>(fn));
	stt[t[c].u]=stt[t[c].v]=0;
}
void getdis(int c)
{
	arr[c][0].clear(),arr[c][1].clear();
	dfsCluster(c,t[c].u,[&](LL d){ arr[c][0].push_back(d); });
	dfsCluster(c,t[c].v,[&](LL d){ arr[c][1].push_back(d); });
	sort(arr[c][0].begin(),arr[c][0].end());
	sort(arr[c][1].begin(),arr[c][1].end());
}
inline int getrk(const vector<LL> &v,LL x)
{
	if(x>=v.back()) return v.size();
	auto it=upper_bound(v.begin(),v.end(),x);
	return it-v.begin();
}

int main()
{
	qin>>n>>m,cnt=n-1;
	for(int i=1,u,v;i<n;i++)
	{
		qin>>u>>v>>L[i];
		g[u].emplace_back(v,i);
		g[v].emplace_back(u,i);
	}
	dfs1(1),dfs2(1),prework();
	B=sqrt(n);
	partition(rt[1]);
	for(int i=1;i<=n;i++)
	{
		sort(g[i].begin(),g[i].end(),[](auto &x,auto &y)
		{ return top[x.second]<top[y.second]; });
		if(i<n) tmps[lb[t[i].v]]+=L[i],tmps[rb[t[i].v]+1]-=L[i];
	}
	tr.build(tmps);
	for(auto &i: blk) getdis(i);
	while(m--)
	{
		LL opt,x,y;
		qin>>opt>>x>>y;
		if(opt==1)
		{
			tr.add(lb[t[x].v],y-L[x]);
			tr.add(rb[t[x].v]+1,L[x]-y);
			L[x]=y,getdis(top[x]);
		}
		else
		{
			int c=top[id[x==1?son[x]:x]],res=0;
			dfsCluster(c,x,[&](LL d){ res+=(d<=y); });
			LL dx=tr.get(lb[x]);
			auto gdis=[&](int v){ return dx+tr.get(lb[v])-2*tr.get(lb[lca(x,v)]); };
			for(auto &j: blk)
			{
				if(j==c) continue;
				LL du=gdis(t[j].u),dv=gdis(t[j].v);
				if(min(du,dv)>y) continue;
				else res+=getrk(arr[j][du<dv?0:1],y-min(du,dv))-1;
			}
			qout<<res<<'\n';
		}
	}
	return 0;
}