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

typedef pair <int, int> pii;
typedef long long ll;

const int N = 2e5 + 5;

struct atom {
    int id, x; ll y;
    atom (int a = 0, int b = 0, ll c = 0) : id(a), x(b), y(c) {}
};

map <pii, int> mp;
vector <int> adj[N];
vector <pii> edg[N];
int u[N], v[N], w[N], tmp[N], bel[N], ans[N], isqry[N];
int n, q;

inline int getid(int u, int v) {
    return mp[minmax(u, v)];
}

int tops[N], pre[N], sizz[N], siz[N], maxn[N], vis[N], fa[N];
int root, allsize, tot;
void getroot(int u, int fa) {
    siz[u] = 1; maxn[u] = 0;
    for (auto v : adj[u]) {
        if (vis[v] || v == fa) continue;
        getroot(v, u); siz[u] += siz[v];
        maxn[u] = max(maxn[u], siz[v]);
    }
    maxn[u] = max(maxn[u], allsize - siz[u]);
    if (maxn[u] < maxn[root]) root = u;
}

ll a[N], b[N], tag[N];
int bb[N], bl[N], br[N];
int B;

void rebuild(int id) {
    for (int i = bl[id]; i <= br[id]; i++) b[i] = a[i];
    sort(b + bl[id], b + br[id] + 1);
}

// 1 ~ tot
void init() {
    B = floor(sqrt(tot) + 0.5);
    for (int i = 1; i <= tot; i++) bl[i] = br[i] = tag[i] = 0;
    for (int i = 1; i <= tot; i++) {
        bb[i] = (i - 1) / B + 1;
        if (!bl[bb[i]]) bl[bb[i]] = i;
        br[bb[i]] = i;
    }
    for (int i = 1; i <= bb[tot]; i++) rebuild(i);
}

void add(int l, int r, ll v) {
    // fprintf(stderr, "l = %d, r = %d, v = %lld\n", l, r, v);
    if (bb[l] == bb[r]) {
        for (int i = l; i <= r; i++) a[i] += v;
        rebuild(bb[l]);
    } else {
        for (int i = l; i <= br[bb[l]]; i++) a[i] += v;
        for (int i = bl[bb[r]]; i <= r; i++) a[i] += v;
        for (int i = bb[l] + 1; i <= bb[r] - 1; i++) tag[i] += v;
        rebuild(bb[l]); rebuild(bb[r]);
    }
}

// <= v
int query(int l, int r, ll v) {
    int ans = 0;
    if (bb[l] == bb[r]) {
        for (int i = l; i <= r; i++) {
            if (a[i] + tag[bb[l]] <= v) ++ans;
        }
    } else {
        for (int i = l; i <= br[bb[l]]; i++) {
            if (a[i] + tag[bb[l]] <= v) ++ans;
        }
        for (int i = bl[bb[r]]; i <= r; i++) {
            if (a[i] + tag[bb[r]] <= v) ++ans;
        }
        for (int i = bb[l] + 1; i <= bb[r] - 1; i++) {
            ans += upper_bound(b + bl[i], b + br[i] + 1, v - tag[i]) - b - bl[i];
        }
    }
    return ans;
}

void dfs1(int u, int rt, ll dis) {
    tops[u] = ++tot; pre[tot] = u; sizz[u] = 1; bel[u] = rt; a[tot] = dis;
    for (auto v : edg[u]) {
        if (vis[v.first] || v.first == fa[u]) continue;
        fa[v.first] = u; tmp[v.second] = w[v.second]; dfs1(v.first, rt, dis + w[v.second]); sizz[u] += sizz[v.first];
    }
}

vector <atom> vec[N];
void solve(int u, vector <atom> qry) {
    vis[u] = 1;
    if (!qry.size()) return;
    bel[u] = u; sizz[u] = 1; tops[u] = tot = 1; pre[1] = u; fa[u] = 0;
    for (auto v : edg[u]) {
        if (vis[v.first]) continue;
        fa[v.first] = u; tmp[v.second] = w[v.second]; dfs1(v.first, v.first, w[v.second]); sizz[u] += sizz[v.first];
    }
    init();
    for (auto v : adj[u]) vec[v].clear();
    for (auto t : qry) {
        if (t.id == 0) {
            int u = ::u[t.x], v = ::v[t.x];
            if (fa[v] == u) swap(u, v);
            add(tops[u], tops[u] + sizz[u] - 1, t.y - tmp[t.x]); tmp[t.x] = t.y;
            if (bel[u] == bel[v]) vec[bel[u]].push_back(t);
        } else {
            ans[t.id] += query(1, tot, t.y - a[tops[t.x]] - tag[bb[tops[t.x]]]);
            if (t.x != u) {
                ans[t.id] -= query(tops[bel[t.x]], tops[bel[t.x]] + sizz[bel[t.x]] - 1, t.y - a[tops[t.x]] - tag[bb[tops[t.x]]]);
                vec[bel[t.x]].push_back(t);
            }
        }
    }
    for (auto v : adj[u]) {
        if (vis[v]) continue;
        root = 0; allsize = (siz[v] < siz[u] ? siz[v] : allsize - siz[u]);
        getroot(v, u); solve(root, vec[v]);
    }
}

int main() {
    scanf("%d%d", &n, &q);
    for (int i = 1; i < n; i++) {
        scanf("%d%d%d", &u[i], &v[i], &w[i]);
        adj[u[i]].push_back(v[i]);
        adj[v[i]].push_back(u[i]);
        edg[u[i]].emplace_back(v[i], i);
        edg[v[i]].emplace_back(u[i], i);
        mp[minmax(u[i], v[i])] = i;
    }
    vector <atom> vec;
    for (int i = 1; i <= q; i++) {
        int op, a; ll b;
        scanf("%d%d%lld", &op, &a, &b);
        if (op == 1) vec.push_back(atom(0, a, b));
        else vec.push_back(atom(i, a, b)), isqry[i] = 1;
    }
    maxn[0] = n + 1; allsize = n; getroot(1, 0); solve(root, vec);
    for (int i = 1; i <= q; i++) {
        if (isqry[i]) printf("%d\n", ans[i]);
    }
    return 0;
}