#include <bits/stdc++.h>

using namespace std;
#define n nnathw
#define fi first
#define se second
#define MAX 100100
#define pb push_back
#define inf 100000000

int n,q;
vector<pair<int,int> > adj[MAX];
int w[MAX], head[MAX], parent[MAX], treesize[MAX], depth[MAX], pos[MAX];
int cnt = 0;

struct segtree
{
    vector<int> st1,st2;
    int n;
    vector<int> a;

    segtree(int _n, vector<int> &_a)
    {
        n = _n;
        a.resize(n+1);
        st1.resize(n*4+10, 0);
        st2.resize(n*4+10,inf);
        for(int i = 1; i<=n; i++) a[i] = _a[i];
    }

    void build(int id, int l, int r)
    {
        if(l == r){
            st2[id] = a[l];
        }else{
            int m = (l+r)/2;
            build(id*2, l,m);
            build(id*2 + 1, m+1, r);
            st2[id] = min(st2[id*2], st2[id*2+1]);
        }
    }

    void update(int id,int l, int r, int pos)
    {
        if(l == r){
            st1[id] = 1;
        }else{
            int m = (l+r)/2;
            if(pos <=m){
                update(id*2,l,m,pos);
            }else{
                update(id*2+1,m+1,r,pos);
            }
            st1[id] = st1[id*2] + st1[id*2 + 1];
        }
    }

    pair<int,int> get(int id, int l, int r, int u, int v)
    {
        if(r < u || v < l) return make_pair(0,inf);
        if(u <= l && r<=v) return make_pair(st1[id], st2[id]);
        int m = (l+r)/2;
        pair<int,int> t1 = get(id*2,l,m,u,v);
        pair<int,int> t2 = get(id*2+1,m+1,r,u,v);
        return make_pair(t1.fi + t2.fi, min(t1.se, t2.se));
    }
};

void nhap()
{
    cin >> n >> q;
    for(int i = 0; i<n-1; i++){
        int a,b,c; cin >> a >> b >> c;
        adj[a].pb(make_pair(b,c));
        adj[b].pb(make_pair(a,c));
    }
    depth[1] = 0;
    w[1] = 0;
    parent[1] = 0;
}

void dfs(int v, int par)
{
    treesize[v] = 1;
    int index = -1;
    int ans_index = -1;
    for(pair<int,int> u : adj[v]){
        ++index;
        if(u.fi == par) continue;
        parent[u.fi] = v;
        w[u.fi] = u.se;
        depth[u.fi] = depth[v] + 1;
        dfs(u.fi, v);
        treesize[v] += treesize[u.fi];
        if(ans_index == -1 || treesize[u.fi] > treesize[adj[v][ans_index].fi]) ans_index = index;
    }
    if(ans_index != -1 && ans_index != 0 ) swap(adj[v][0], adj[v][ans_index]);
}

void decompose(int v, int par, int h)
{
    head[v] = h;
    pos[v] = ++cnt;
    for(pair<int,int> u : adj[v]){
        if(u.fi == par) continue;
        if(u.fi == adj[v][0].fi){
            decompose(u.fi,v,h);
        }else{
            decompose(u.fi,v,u.fi);
        }
    }
}

void process()
{
    vector<int> a(n+1);
    for(int i = 1; i<=n; i++) a[pos[i]] = w[i];
    segtree st(n,a);
    st.build(1,1,n);
    while(q--)
    {

    int type; cin >> type;

    if(type == 2){
        int s; cin >> s;
        st.update(1,1,n,pos[s]);
    }else{
        int u,v; cin >> u >> v;
        if(u == v){
            cout << 0 << endl;
            continue;
        }
        bool flag = true;
        int res = inf;
        while(head[u] != head[v]){
            if(depth[head[u]] < depth[head[v]]) swap(u,v);
            pair<int,int> k = st.get(1,1,n,pos[head[u]],pos[u]);
            if(k.fi != 0){
                flag = false;
                break;
            }
            res = min(res,k.se);
            u = parent[head[u]];
        }
        if(depth[u] > depth[v]) swap(u,v);
        pair<int,int> k = st.get(1,1,n,pos[u]+1,pos[v]);
        res = min(res,k.se);
        if(k.fi != 0) flag = false;
        k = st.get(1,1,n,pos[u],pos[u]);
        if(k.fi != 0) flag = false;
        if(flag){
            cout << res << endl;
        }else{
            cout << -1 << endl;
        }
    }

    }
}

signed main()
{
    ios_base::sync_with_stdio(0); cin.tie(0);
//    freopen("backup.inp","r",stdin);
//    freopen("backup.out","w",stdout);
    nhap();
    dfs(1,-1);
    decompose(1,-1,-1);
    process();
    return 0;
}