#include <cstdio>
#include <iostream>
#include <fstream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <memory.h>
#include <sstream>
#include <complex>
#include <cassert>
#include <functional>

#define REP(i,n) for(int i = 0, _n = (n); i < _n; i++)
#define REPD(i,n) for(int i = (n) - 1; i >= 0; i--)
#define FOR(i,a,b) for (int i = (a), _b = (b); i <= _b; i++)
#define FORD(i,a,b) for (int i = (a), _b = (b); i >= _b; i--)
#define FORN(i,a,b) for(int i=a;i<b;i++)
#define FOREACH(it,c) for (__typeof((c).begin()) it=(c).begin();it!=(c).end();it++)
#define RESET(c,x) memset (c, x, sizeof (c))

#define PI acos(-1)
#define sqr(x) ((x) * (x))
#define PB push_back
#define MP make_pair
#define F first
#define S second
#define Aint(c) (c).begin(), (c).end()
#define SIZE(c) (c).size()

#define DEBUG(x) { cerr << #x << " = " << x << endl; }
#define PR(a,n) {cerr<<#a<<" = "; FOR(_,1,n) cerr << a[_] << ' '; cerr <<endl;}
#define PR0(a,n) {cerr<<#a<<" = ";REP(_,n) cerr << a[_] << ' '; cerr << endl;}
#define LL long long

using namespace std;

#define MAXN 112345
#define LOGN 20

int parent[MAXN], size[MAXN], length[MAXN], cost[MAXN], depth[MAXN], dfsOrder[MAXN], pos[MAXN], f[MAXN][LOGN + 1];
int node[MAXN * 4], n, len;
vector <pair<int, int> > adj[MAXN];
pair<int, int> edge[MAXN];

void dfs(int u) {
    dfsOrder[++len] = u;
    pos[u] = len;

    if (u != 1) {
        f[u][0] = parent[u];
        for (int i = 1; i <= LOGN; i++)
            f[u][i] = f[f[u][i - 1]][i - 1];
    }
    size[u] = 1;

    for (int i = 0; i < (int) adj[u].size(); i++) {
        int v = adj[u][i].first;

        if (parent[v] == 0) {
            parent[v] = u;
            depth[v] = depth[u] + 1;
            length[v] = length[u] + adj[u][i].second;
            dfs(v);
            size[u] += size[v];
        }
    }
}

void init() {
    //find dfs order
    //prepare information for finding lca

    parent[1] = 1;
    depth[1] = 1;
    len = 0;

    dfs(1);
}

void update(int s, int l, int r, int u, int v, int c) {
    if (r < u || v < l) return;
    if (u <= l && r <= v) {
        node[s] += c;
        return;
    }

    int s1 = s * 2, mid = (l + r) / 2, s2 = s * 2 + 1;
    update(s1, l, mid, u, v, c);
    update(s2, mid + 1, r, u, v, c);
}

int get(int s, int l, int r, int u) {
    if (u < l || r < u) return 0;
    if (l == r) return node[s];

    int s1 = s * 2, mid = (l + r) / 2, s2 = s * 2 + 1;
    return get(s1, l, mid, u) + get(s2, mid + 1, r, u) + node[s];
}

int lca(int u, int v) {
    if (depth[u] < depth[v]) swap(u, v);

    for (int i = LOGN; i >= 0; i--)
        if (depth[f[u][i]] >= depth[v]) u = f[u][i];

    if (u == v) return v;

    for (int i = LOGN; i >= 0; i--)
        if (f[u][i] != f[v][i]) {
            u = f[u][i];
            v = f[v][i];
        }

    return f[u][0];
}

int getPath(int u) {
    return get(1, 1, n, pos[u]) + length[u];
}

int main() {
    //freopen("a.in", "rb", stdin); 
    //freopen("a.out", "wb", stdout);
    
    cin >> n;
    
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v >> cost[i];

        edge[i] = make_pair(u, v);
        adj[u].push_back(make_pair(v, cost[i]));
        adj[v].push_back(make_pair(u, cost[i]));
    }

    init();
    
    int q;
    cin >> q;
    while (q--) {
        int t, u, v, newc, index;
        cin >> t;

        if (t == 1) {
            cin >> index >> newc;
            int u = edge[index].first;
            int v = edge[index].second;
            if (parent[u] != v) swap(u, v);
            //now parent[v] = u.
            //change the weight of the edge connecting u and v will affect all the nodes in the sub-tree rooted at v.

            int change = newc - cost[index];
            cost[index] = newc;

            //change is the difference between the current value and the new value
            //=> we add change in all the nodes in the sub-tree rooted at v
            update(1, 1, n, pos[u], pos[u] + size[u] - 1, change);
        }
        else if (t == 2) {
            cin >> u >> v;
            
            int p = lca(u, v);
            //getPath(u) is the distance from 1 to u.
            cout << getPath(u) + getPath(v) - 2 * getPath(p) << endl;
        }
        else assert(0);
    }
    return 0;
}