#include <bits/stdc++.h>

using i64 = long long;

constexpr int N = 2E5;
constexpr int LogN = 20;

int n, q;
int x[N], y[N], w[N];
std::vector<int> adj[N];

int cdep[N], cpar[N], siz[N];
int par[LogN][N], in[LogN][N], out[LogN][N], seq[LogN][N];
int st[LogN][N];
i64 A[LogN][N], B[LogN][N];
bool vis[N];
int cur[LogN];
int blk[N + 1];

void dfs(int d, int x) {
    in[d][x] = cur[d]++;
    seq[d][in[d][x]] = x;
    siz[x] = 1;
    for (auto y : adj[x]) {
        if (vis[y] || y == par[d][x]) {
            continue;
        }
        par[d][y] = x;
        dfs(d, y);
        siz[x] += siz[y];
    }
    out[d][x] = cur[d];
}

int find(int x, int p, int s) {
    for (auto y : adj[x]) {
        if (vis[y] || y == p || 2 * siz[y] <= s) {
            continue;
        }
        return find(y, x, s);
    }
    return x;
}

int solve(int d, int r) {
    int t = cur[d];
    par[d][r] = -1;
    dfs(d, r);
    r = find(r, -1, siz[r]);
    par[d][r] = -1;
    cur[d] = t;
    dfs(d, r);
    cdep[r] = d;
    vis[r] = true;
    for (auto y : adj[r]) {
        if (vis[y]) {
            continue;
        }
        y = solve(d + 1, y);
        cpar[y] = r;
    }
    return r;
}

int lca(int u, int v) {
    if (u == v) {
        return u;
    }
    u = in[0][u];
    v = in[0][v];
    if (u > v) {
        std::swap(u, v);
    }
    int k = std::__lg(v - u);
    int a = st[k][u];
    int b = st[k][v - (1 << k)];
    return in[0][a] < in[0][b] ? a : b;
}

i64 getdep(int u) {
    return A[0][in[0][u]];
}

i64 dist(int u, int v) {
    int l = lca(u, v);
    return getdep(u) + getdep(v) - 2 * getdep(l);
}

void modify(int i, int c) {
    int X = x[i], Y = y[i];
    int u = X, v = Y;
    while (cdep[u] > cdep[v]) {
        u = cpar[u];
    }
    while (cdep[v] > cdep[u]) {
        v = cpar[v];
    }
    while (u != v) {
        u = cpar[u];
        v = cpar[v];
    }
    while (u != -1) {
        int d = cdep[u];
        int l = std::max(in[d][X], in[d][Y]);
        int r = std::min(out[d][X], out[d][Y]);
        for (int j = l; j < r; j++) {
            A[d][j] += c;
        }
        u = cpar[u];
    }
}

int query(int x, i64 L) {
    int ans = 0;
    for (int i = 0; i < n; i++) {
        ans += dist(x, i) <= L;
    }
    return ans;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    for (int i = 1; i <= N; i++) {
        blk[i] = std::sqrt(i);
    }
    
    std::cin >> n >> q;
    
    for (int i = 1; i < n; i++) {
        std::cin >> x[i] >> y[i] >> w[i];
        x[i]--, y[i]--;
        adj[x[i]].push_back(y[i]);
        adj[y[i]].push_back(x[i]);
    }
    cpar[solve(0, 0)] = -1;
    
    for (int i = 0; i < n; i++) {
        if (in[0][i] != 0) {
            st[0][in[0][i] - 1] = par[0][i];
        }
    }
    for (int k = 0; k + 1 < LogN; k++) {
        for (int i = 0; i + (2 << k) <= n - 1; i++) {
            int a = st[k][i];
            int b = st[k][i + (1 << k)];
            st[k + 1][i] = in[0][a] < in[0][b] ? a : b;
        }
    }
    
    for (int i = 1; i < n; i++) {
        modify(i, w[i]);
    }
    
    for (int _ = 0; _ < q; _++) {
        int o;
        std::cin >> o;
        
        if (o == 1) {
            int i, c;
            std::cin >> i >> c;
            modify(i, c - w[i]);
            w[i] = c;
        } else {
            int x;
            i64 d;
            std::cin >> x >> d;
            x--;
            std::cout << query(x, d) << "\n";
        }
    }
    
    return 0;
}