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

/**
 * Segment Tree supporting:
 * - Range increment updates
 * - Point queries
 */
class SegmentTree {
    vector<long long> tree, lazy;
    int size;

public:
    explicit SegmentTree(int n) : size(n) {
        tree.assign(4 * n + 5, 0);
        lazy.assign(4 * n + 5, 0);
    }

    // Build the tree from a given array
    void build(int idx, int left, int right, const vector<long long>& values) {
        if (left == right) {
            tree[idx] = values[left];
            return;
        }
        int mid = (left + right) / 2;
        build(idx * 2, left, mid, values);
        build(idx * 2 + 1, mid + 1, right, values);
    }

    // Lazy range update
    void update(int idx, int ql, int qr, int left, int right, long long val) {
        if (qr < left || ql > right) return;
        if (ql <= left && right <= qr) {
            lazy[idx] += val;
            return;
        }
        int mid = (left + right) / 2;
        update(idx * 2, ql, qr, left, mid, val);
        update(idx * 2 + 1, ql, qr, mid + 1, right, val);
    }

    // Point query: propagate laziness as we go down
    long long query(int idx, int pos, int left, int right) {
        if (pos < left || pos > right) return 0;
        if (left == right) {
            tree[idx] += lazy[idx];
            lazy[idx] = 0;
            return tree[idx];
        }

        // push lazy value to children
        lazy[idx * 2] += lazy[idx];
        lazy[idx * 2 + 1] += lazy[idx];
        lazy[idx] = 0;

        int mid = (left + right) / 2;
        if (pos <= mid) return query(idx * 2, pos, left, mid);
        else return query(idx * 2 + 1, pos, mid + 1, right);
    }
};

// Global timer for Euler tour
int timer = 1;

/**
 * DFS to compute:
 * - timeIn/timeOut for each node
 * - prefix sum (sumToRoot)
 * - binary lifting table
 */
void dfs(int node, int parent,
         const vector<vector<pair<int, int>>>& graph,
         vector<int>& timeIn, vector<int>& timeOut,
         vector<long long>& sumToRoot,
         vector<vector<int>>& up) {
    
    timeIn[node] = timer++;

    for (auto [child, weight] : graph[node]) {
        if (child == parent) continue;
        up[child][0] = node;
        sumToRoot[child] = sumToRoot[node] + weight;
        dfs(child, node, graph, timeIn, timeOut, sumToRoot, up);
    }

    timeOut[node] = timer;
}

/** Checks if 'a' is an ancestor of 'b' */
bool isAncestor(int a, int b, const vector<int>& timeIn, const vector<int>& timeOut) {
    return timeIn[a] <= timeIn[b] && timeOut[a] >= timeOut[b];
}

/** Compute Lowest Common Ancestor (LCA) using binary lifting */
int findLCA(int u, int v, const vector<vector<int>>& up,
            const vector<int>& timeIn, const vector<int>& timeOut) {

    if (isAncestor(u, v, timeIn, timeOut)) return u;
    if (isAncestor(v, u, timeIn, timeOut)) return v;

    for (int i = 24; i >= 0; --i) {
        int ancestor = up[u][i];
        if (ancestor && !isAncestor(ancestor, v, timeIn, timeOut)) {
            u = ancestor;
        }
    }
    return up[u][0];
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    vector<vector<pair<int, int>>> graph(n + 1);
    vector<int> from(n), to(n), weight(n);

    // Input edges
    for (int i = 1; i < n; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        from[i] = u;
        to[i] = v;
        weight[i] = w;
        graph[u].push_back({v, w});
        graph[v].push_back({u, w});
    }

    vector<int> timeIn(n + 1), timeOut(n + 1);
    vector<long long> sumToRoot(n + 1, 0);
    vector<vector<int>> up(n + 1, vector<int>(25, 0));

    // Run DFS from root (1)
    dfs(1, 0, graph, timeIn, timeOut, sumToRoot, up);

    // Build binary lifting table
    for (int j = 1; j < 25; j++) {
        for (int i = 1; i <= n; i++) {
            int parent = up[i][j - 1];
            up[i][j] = parent ? up[parent][j - 1] : 0;
        }
    }

    // Align edges so "from" is always parent and "to" is child
    for (int i = 1; i < n; i++) {
        if (timeIn[from[i]] > timeIn[to[i]]) swap(from[i], to[i]);
    }

    // Prepare array for segment tree using DFS order
    vector<long long> dfsArray(n + 1, 0);
    for (int i = 1; i <= n; i++) dfsArray[timeIn[i]] = sumToRoot[i];

    SegmentTree seg(n + 1);
    seg.build(1, 0, n, dfsArray);

    int q;
    cin >> q;

    while (q--) {
        int type;
        cin >> type;

        if (type == 1) {
            // Update edge weight
            int edgeIdx, newWeight;
            cin >> edgeIdx >> newWeight;

            int u = from[edgeIdx];
            int v = to[edgeIdx];
            long long delta = newWeight - weight[edgeIdx];
            weight[edgeIdx] = newWeight;

            int l = timeIn[v], r = timeOut[v] - 1;
            if (l <= r) seg.update(1, l, r, 0, n, delta);

        } else if (type == 2) {
            // Query distance between two nodes
            int u, v;
            cin >> u >> v;

            long long distU = seg.query(1, timeIn[u], 0, n);
            long long distV = seg.query(1, timeIn[v], 0, n);

            if (isAncestor(u, v, timeIn, timeOut) || isAncestor(v, u, timeIn, timeOut)) {
                cout << llabs(distU - distV) << '\n';
            } else {
                int lca = findLCA(u, v, up, timeIn, timeOut);
                long long distLCA = seg.query(1, timeIn[lca], 0, n);
                cout << llabs(distU + distV - 2 * distLCA) << '\n';
            }
        }
    }

    return 0;
}