#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], tag[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) {
    int x = in[0][u];
    return A[0][x] + tag[0][x - x % blk[n]];
}

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

void add(int d, int x, int l, int r, int c) {
    int L = in[d][x], R = out[d][x];
    int n = R - L;
    int b = blk[n];
    int lb = (l - L) / b;
    int rb = (r - 1 - L) / b;
    if (lb == rb) {
        for (int i = l; i < r; i++) {
            A[d][i] += c;
        }
        l = L + lb * b;
        r = std::min(R, l + b);
        std::copy(A[d] + l, A[d] + r, B[d] + l);
        std::sort(B[d] + l, B[d] + r);
    } else {
        for (int i = l; i < L + (lb + 1) * b; i++) {
            A[d][i] += c;
        }
        for (int i = lb + 1; i < rb; i++) {
            tag[d][L + i * b] += c;
        }
        for (int i = L + rb * b; i < r; i++) {
            A[d][i] += c;
        }
        l = L + lb * b;
        r = std::min(R, l + b);
        std::copy(A[d] + l, A[d] + r, B[d] + l);
        std::sort(B[d] + l, B[d] + r);
        l = L + rb * b;
        r = std::min(R, l + b);
        std::copy(A[d] + l, A[d] + r, B[d] + l);
        std::sort(B[d] + l, B[d] + r);
    }
}

int get(int d, int x, int l, int r, i64 v) {
    if (l == r) {
        return 0;
    }
    int L = in[d][x], R = out[d][x];
    int n = R - L;
    int b = blk[n];
    int lb = (l - L) / b;
    int rb = (r - 1 - L) / b;
    int res = 0;
    if (lb == rb) {
        i64 t = tag[d][L + lb * b];
        for (int i = l; i < r; i++) {
            res += (A[d][i] + t <= v);
        }
    } else {
        i64 t = tag[d][L + lb * b];
        for (int i = l; i < L + (lb + 1) * b; i++) {
            res += (A[d][i] + t <= v);
        }
        for (int i = lb + 1; i < rb; i++) {
            int l = L + i * b;
            int r = l + b;
            t = tag[d][l];
            res += std::upper_bound(B[d] + l, B[d] + r, v - t) - B[d] - l;
        }
        t = tag[d][L + rb * b];
        for (int i = L + rb * b; i < r; i++) {
            res += (A[d][i] + t <= v);
        }
    }
    return res;
}

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]);
        add(d, u, l, r, c);
        u = cpar[u];
    }
}

int query(int x, i64 L) {
    int ans = 0;
    int y = -1;
    for (int i = x; i != -1; y = i, i = cpar[i]) {
        i64 dis = dist(x, i);
        int d = cdep[i];
        if (y != -1) {
            ans += get(d, i, in[d][i], in[d][y], L - dis);
            ans += get(d, i, out[d][y], out[d][i], L - dis);
        } else {
            ans += get(d, i, in[d][i], out[d][i], L - dis);
        }
    }
    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;
}