//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC target ("avx2")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=1000*1007;
const int d=450;

int n, q;

vector<pii> graf[nax];
pii kra[nax];//dziecko, ojciec
ll wag[nax];

int ojc[nax];
int dooj[nax];

int duzy[nax];
vi duze;

int super_ojciec[nax];
vi super_dzieci[nax];
int ktora_super[nax];
ll suma_super[nax];

vi sciezka[nax];

ordered_set<pll> dzieci[nax];
vector<pll> gora_super[nax];
vector<pll> dol_super[nax];

int wyn;

pii dfs1(int v)
{
	for (pii &i : graf[v])
	{
		if (i.first==ojc[v])
		{
			swap(i, graf[v].back());
			graf[v].pop_back();
			break;
		}
	}
	pii ret{0, 1};
	for (pii i : graf[v])
	{
		ojc[i.first]=v;
		dooj[i.first]=i.second;
		pii wez=dfs1(i.first);
		ret.first+=wez.first;
		ret.second+=wez.second;
	}
	if (ret.first>1 || ret.second>=d || v==1)
	{
		ret={1, 0};
		duzy[v]=1;
		duze.push_back(v);
	}
	return ret;
}

vector<pll> glo;

void glo_zbierz(int v, ll s, int zakaz=-1, int startuje=1)
{
	if (startuje)
		glo.clear();
	if (duzy[v])
		return;
	glo.push_back({s, v});
	for (pii i : graf[v])
		if (i.first!=zakaz)
			glo_zbierz(i.first, s+wag[i.second], zakaz, 0);
}

//~ int od_gory_ograniczone(int v, ll x)
//~ {
	//~ return dzieci[v].order_of_key({x, nax});
//~ }

void akcja(int v, int sko, ll lim)
{
	if (lim<0)
		return;
	wyn++;
	wyn+=dzieci[v].order_of_key({lim, nax});
	if (v>1 && sko!=super_ojciec[v])
	{
		wyn+=lower_bound(gora_super[v].begin(), gora_super[v].end(), pll{lim, nax})-gora_super[v].begin();
		akcja(super_ojciec[v], v, lim-suma_super[v]);
	}
	for (int i : super_dzieci[v])
	{
		if (i==sko)
			continue;
		wyn+=lower_bound(dol_super[i].begin(), dol_super[i].end(), pll{lim, nax})-dol_super[i].begin();
		akcja(i, v, lim-suma_super[i]);
	}
}

int znajdz_na_sciezce(int v, int kogo)
{
	for (int i=0; i<(int)sciezka[v].size(); i++)
		if (sciezka[v][i]==kogo)
			return i;
	assert(0);
}

ll zmien[nax];

void oznacz(int v, int zakaz, ll delta)
{
	if (duzy[v])
		return;
	zmien[v]=delta;
	for (pii i : graf[v])
		if (i.first!=zakaz)
			oznacz(i.first, zakaz, delta);
}

void popraw(vector<pll> &wek)
{
	static vector<pll> a, b;
	a.clear();
	b.clear();
	for (pll &i : wek)
	{
		i.first+=zmien[i.second];
		zmien[i.second]=0;
		if (a.empty() || a.back()<=i)
			a.push_back(i);
		else
			b.push_back(i);
	}
	wek.clear();
	int wa=0;
	int wb=0;
	while(wa<(int)a.size() || wb<(int)b.size())
	{
		if (wb==(int)b.size() || (wa<(int)a.size() && a[wa]<b[wb]))
		{
			wek.push_back(a[wa]);
			wa++;
		}
		else
		{
			wek.push_back(b[wb]);
			wb++;
		}
	}
}

void update(int v, ll w)
{
	ll delta=w-wag[v];
	ll stawag=wag[v];
	wag[v]=w;
	v=kra[v].first;
	
	if (ktora_super[v])
	{
		int kt=ktora_super[v];
		int g=znajdz_na_sciezce(kt, v);
		
		ll nad=0;
		ll pod=0;
		for (int i=0; i<g; i++)
			pod+=wag[dooj[sciezka[kt][i]]];
		for (int i=g+1; i<(int)sciezka[kt].size(); i++)
			nad+=wag[dooj[sciezka[kt][i]]];
		
		//~ glo_zbierz(sciezka[kt][g], nad);
		//~ for (pll j : glo)
			//~ zmien[j.second]=delta;
		oznacz(sciezka[kt][g], -1, delta);
		popraw(dol_super[kt]);
		//~ for (pll j : glo)
		//~ {
			//~ dol_super[kt].erase({stawag+j.first, j.second});
			//~ dol_super[kt].insert({w+j.first, j.second});
		//~ }
		/*for (int i=g+1; i<(int)sciezka[kt].size(); i++)
		{
			glo_zbierz(sciezka[kt][i], pod, sciezka[kt][i-1]);
			for (pll j : glo)
				zmien[j.second]=delta;
			//~ for (pll j : glo)
			//~ {
				//~ gora_super[kt].erase({stawag+j.first, j.second});
				//~ gora_super[kt].insert({w+j.first, j.second});
			//~ }
			pod+=wag[dooj[sciezka[kt][i]]];
		}*/
		oznacz(sciezka[kt].back(), sciezka[kt][g], delta);
		popraw(gora_super[kt]);
		
		suma_super[kt]+=delta;
		return;
	}
	
	ll sum=0;
	int u=ojc[v];
	while(!ktora_super[u] && !duzy[u])
	{
		sum+=wag[dooj[u]];
		u=ojc[u];
	}
	if (duzy[u])
	{
		glo_zbierz(v, sum);
		for (pll j : glo)
		{
			dzieci[u].erase({stawag+j.first, j.second});
			dzieci[u].insert({w+j.first, j.second});
		}
	}
	else
	{
		int kt=ktora_super[u];
		//~ int g=znajdz_na_sciezce(kt, u);
		//~ ll nad=0;
		//~ ll pod=0;
		//~ for (int i=0; i<g; i++)
			//~ pod+=wag[dooj[sciezka[kt][i]]];
		//~ for (int i=g; i<(int)sciezka[kt].size(); i++)
			//~ nad+=wag[dooj[sciezka[kt][i]]];
		
		//~ debug() << imie(sum) << imie(u) << imie(v) << imie(pod) << imie(nad);
		
		oznacz(v, -1, delta);
		popraw(gora_super[kt]);
		oznacz(v, -1, delta);
		popraw(dol_super[kt]);
		
		//~ for (pll j : glo)
		//~ {
			//~ gora_super[kt].erase({pod+stawag+j.first, j.second});
			//~ gora_super[kt].insert({pod+w+j.first, j.second});
			
			//~ dol_super[kt].erase({nad+stawag+j.first, j.second});
			//~ dol_super[kt].insert({nad+w+j.first, j.second});
		//~ }
	}
}

int main()
{
	scanf("%d%d", &n, &q);
	for (int i=1; i<n; i++)
	{
		int a, b;
		scanf("%d%d%lld", &a, &b, &wag[i]);
		kra[i]={a, b};
		graf[a].push_back({b, i});
		graf[b].push_back({a, i});
	}
	dfs1(1);
	for (int i=1; i<n; i++)
		if (ojc[kra[i].second]==kra[i].first)
			swap(kra[i].first, kra[i].second);
	debug() << imie(duze) << imie(duze.size());
	for (int i=2; i<=n; i++)
	{
		if (!duzy[i])
			continue;
		int v=i;
		while(v==i || !duzy[v])
		{
			sciezka[i].push_back(v);
			ktora_super[v]=i;
			suma_super[i]+=wag[dooj[v]];
			v=ojc[v];
		}
		super_ojciec[i]=v;
		super_dzieci[v].push_back(i);
		
		ll w=0;
		for (int j=1; j<(int)sciezka[i].size(); j++)
		{
			w+=wag[dooj[sciezka[i][j-1]]];
			glo_zbierz(sciezka[i][j], 0, sciezka[i][j-1]);
			for (pll l : glo)
			{
				gora_super[i].push_back({w+l.first, l.second});
				dol_super[i].push_back({suma_super[i]-w+l.first, l.second});
			}
		}
		sort(gora_super[i].begin(), gora_super[i].end());
		sort(dol_super[i].begin(), dol_super[i].end());
	}
	
	for (int i=1; i<=n; i++)
	{
		if (!duzy[i])
			continue;
		for (pii j : graf[i])
		{
			if (ktora_super[j.first])
				continue;
			glo_zbierz(j.first, wag[j.second]);
			for (pll l : glo)
				dzieci[i].insert(l);
		}
	}
	
	while(q--)
	{
		int typ;
		scanf("%d", &typ);
		if (typ==1)
		{
			int v;
			ll w;
			scanf("%d%lld", &v, &w);
			update(v, w);
		}
		else
		{
			int v;
			ll lim;
			scanf("%d%lld", &v, &lim);
			wyn=0;
			
			
			int u=v;
			int ost=-1;
			while(!ktora_super[u] && !duzy[u])
			{
				glo_zbierz(u, 0, ost);
				for (pll j : glo)
					if (j.first<=lim)
						wyn++;
				ost=u;
				lim-=wag[dooj[u]];
				u=ojc[u];
			}
			
			
			if (duzy[u])
			{
				if (ost!=-1)
				{
					glo_zbierz(ost, wag[dooj[ost]]);
					for (pll j : glo)
						if (j.first<=lim)
							wyn--;
				}
				akcja(u, -1, lim);
			}
			else
			{
				int w=ktora_super[u];
				
				ll bylo=lim;
				ll zbi=0;
				while(!duzy[u])
				{
					glo_zbierz(u, 0, ost);
					for (pll j : glo)
						if (j.first<=lim)
							wyn++;
					ost=u;
					zbi+=wag[dooj[u]];
					lim-=wag[dooj[u]];
					u=ojc[u];
				}
				
				akcja(u, w, lim);
				akcja(w, u, bylo-(suma_super[w]-zbi));
			}
			
			printf("%d\n", wyn);
		}
	}
	return 0;
}