You are given a directed weighted graph with n nodes and 2n - 2 edges. The nodes are labeled from 1 to n, while the edges are labeled from 1 to 2n - 2. The graph's edges can be split into two parts.

  * The first n - 1 edges will form a rooted spanning tree, with node 1 as the root. All these edges will point away from the root. 
  * The last n - 1 edges will be from node i to node 1, for all 2 ≤ i ≤ n. 



You are given q queries. There are two types of queries

  * 1 i w: Change the weight of the i-th edge to w
  * 2 u v: Print the length of the shortest path between nodes u to v



Given these queries, print the shortest path lengths.

Input

The first line of input will contain two integers n, q (2 ≤ n, q ≤ 200 000), the number of nodes, and the number of queries, respectively.

The next 2n - 2 integers will contain 3 integers ai, bi, ci, denoting a directed edge from node ai to node bi with weight ci.

The first n - 1 of these lines will describe a rooted spanning tree pointing away from node 1, while the last n - 1 of these lines will have bi = 1.

More specifically, 

  * The edges (a1, b1), (a2, b2), ... (an - 1, bn - 1) will describe a rooted spanning tree pointing away from node 1. 
  * bj = 1 for n ≤ j ≤ 2n - 2. 
  * an, an + 1, ..., a2n - 2 will be distinct and between 2 and n. 



The next q lines will contain 3 integers, describing a query in the format described in the statement.

All edge weights will be between 1 and 106.

Output

For each type 2 query, print the length of the shortest path in its own line.

Example

Input

5 9
1 3 1
3 2 2
1 4 3
3 5 4
5 1 5
3 1 6
2 1 7
4 1 8
2 1 1
2 1 3
2 3 5
2 5 2
1 1 100
2 1 3
1 8 30
2 4 2
2 2 4


Output

0
1
4
8
100
132
10
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 400000 + 1;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const long double PI = 3.141592653589793238462;
long long n, q;
long long stt[MAX_N], enn[MAX_N];
vector<long long> v[MAX_N];
pair<long long, pair<long long, long long> > all[MAX_N];
long long flag[2 * MAX_N], flag1[2 * MAX_N], MIN[2 * MAX_N];
long long t = 1;
long long edges[MAX_N];
long long find(long long node, long long st, long long en, long long low,
               long long high) {
  if (st == low && en == high) {
    return MIN[node];
  }
  long long mid = (st + en) / 2;
  if (high <= mid)
    return find(2 * node, st, mid, low, high) + flag[node];
  else if (low > mid)
    return find(2 * node + 1, mid + 1, en, low, high) + flag[node];
  else
    return min(find(2 * node, st, mid, low, mid),
               find(2 * node + 1, mid + 1, en, mid + 1, high)) +
           flag[node];
}
void add(long long node, long long st, long long en, long long low,
         long long high, long long val) {
  if (st == low && high == en) {
    flag[node] += val;
    MIN[node] += val;
    return;
  }
  long long mid = (st + en) / 2;
  if (high <= mid) {
    add(2 * node, st, mid, low, high, val);
    MIN[node] = min(MIN[2 * node], MIN[2 * node + 1]) + flag[node];
    return;
  } else if (low > mid) {
    add(2 * node + 1, mid + 1, en, low, high, val);
    MIN[node] = min(MIN[2 * node], MIN[2 * node + 1]) + flag[node];
    return;
  } else {
    add(2 * node, st, mid, low, mid, val);
    add(2 * node + 1, mid + 1, en, mid + 1, high, val);
    MIN[node] = min(MIN[2 * node], MIN[2 * node + 1]) + flag[node];
    return;
  }
}
void dfs(long long u) {
  stt[u] = t++;
  for (long long i = 0; i < v[u].size(); i++) dfs(v[u][i]);
  enn[u] = t - 1;
}
bool is_par(long long a, long long b) {
  if (stt[b] >= stt[a] && enn[b] <= enn[a]) return true;
  return false;
}
int main() {
  ios_base::sync_with_stdio(false);
  cin >> n >> q;
  for (long long i = 1; i < n; i++) {
    cin >> all[i].first >> all[i].second.first >> all[i].second.second;
    v[all[i].first].push_back(all[i].second.first);
  }
  for (long long i = n; i < 2 * n - 1; i++) {
    cin >> all[i].first >> all[i].second.first >> all[i].second.second;
    edges[all[i].first] = all[i].second.second;
  }
  dfs(1);
  for (long long i = 1; i < n; i++) {
    long long u = all[i].second.first;
    add(1, 1, n, stt[u], enn[u], all[i].second.second);
  }
  for (int i = n; i < 2 * n - 1; i++) {
    long long u = all[i].first;
    add(1, 1, n, stt[u], stt[u], all[i].second.second);
  }
  for (long long i = 1; i <= q; i++) {
    long long a, b, c;
    cin >> a >> b >> c;
    if (a == 1) {
      if (b <= n - 1) {
        long long change = c - all[b].second.second;
        long long u = all[b].second.first;
        add(1, 1, n, stt[u], enn[u], change);
        all[b].second.second = c;
      } else {
        long long u = all[b].first;
        long long change = c - edges[u];
        add(1, 1, n, stt[u], stt[u], change);
        edges[all[b].first] = c;
      }
    } else {
      if (is_par(b, c)) {
        long long x = find(1, 1, n, stt[b], stt[b]);
        long long y = find(1, 1, n, stt[c], stt[c]);
        x -= edges[b];
        y -= edges[c];
        cout << y - x;
      } else {
        long long x = find(1, 1, n, stt[b], enn[b]);
        long long y = find(1, 1, n, stt[b], stt[b]);
        y -= edges[b];
        x -= y;
        long long z = find(1, 1, n, stt[c], stt[c]);
        z -= edges[c];
        cout << x + z;
      }
      cout << endl;
    }
  }
}
