#include<cstdio>

#include<algorithm>

#include<cstring>

#include<iostream>

#include<cmath>

#include<cctype>

#include<set>

#include<queue>

#include<vector>

#include<map>

using namespace std;

typedef long long LL;

inline int read() {

    int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

    for(;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

}

const int N = ;

struct Data { int ty, a, b, v, c; } A[N], B[N], C[N];

struct Edge { int to, nxt; } e[N << ];

int head[N], f[N][], dfn[N], dep[N], siz[N], ans[N], En, Index;

inline void add_edge(int u,int v) {

    ++En; e[En].to = v, e[En].nxt = head[u]; head[u] = En;

    ++En; e[En].to = u, e[En].nxt = head[v]; head[v] = En;

}

int LCA(int u,int v) {

    if (dep[u] < dep[v]) swap(u, v);

    int d = dep[u] - dep[v];

    for (int i = ; ~i; --i) if ((d >> i) & ) u = f[u][i];

    if (u == v) return u;

    for (int i = ; ~i; --i) if (f[u][i] != f[v][i]) u = f[u][i], v = f[v][i];

    return f[u][];

}

void dfs(int u) {

    for (int j = ; j <= ; ++j) f[u][j] = f[f[u][j - ]][j - ];

    dep[u] = dep[f[u][]] + ;

    dfn[u] = ++Index; siz[u] = ;

    for (int i = head[u]; i; i = e[i].nxt) {

        int v = e[i].to;

        if (v == f[u][]) continue;

        f[v][] = u;

        dfs(v);

        siz[u] += siz[v];

    }

}

struct Bit{

    int sum[N << ], n;

    void clear() { memset(sum, , sizeof(sum)); }

    void update(int p,int v) { if (p == ) return ; for (; p <= n; p += (p & (-p))) sum[p] += v; }

    int query(int p) {

        int ans = ;

        for (; p; p -= (p & (-p))) ans += sum[p];

        return ans;

    }

    int Ask(int l,int r) { return query(r) - query(l - ); }

}bit;

void add(Data &A,int ty) {

    ty = ty ? - : ;

    bit.update(dfn[A.a], ty);

    bit.update(dfn[A.b], ty);

    bit.update(dfn[A.c], -ty);

    bit.update(dfn[f[A.c][]], -ty);

}

void solve(int l,int r,int H,int T) {

    if (H > T) return ;

    if (l == r) {

        for (int i = H; i <= T; ++i) if (A[i].ty == ) ans[A[i].b] = l;

        return ;

    }

    int mid = (l + r + ) >> , cl = H, cr = T, now = ;

    for (int i = H; i <= T; ++i) {

        if (A[i].ty <= ) {

            if (A[i].v < mid) B[cl ++] = A[i];

            else add(A[i], A[i].ty), B[cr --] = A[i], now += (A[i].ty ? - : );

        }

        else {

            int t = bit.Ask(dfn[A[i].a], dfn[A[i].a] + siz[A[i].a] - );

            if (t == now) B[cl ++] = A[i];

            else B[cr --] = A[i];

        }

    }

    for (int i = H; i <= T; ++i) if (A[i].ty <=  && A[i].v >= mid) add(A[i], !A[i].ty);

    for (int i = H; i < cl; ++i) A[i] = B[i];

    for (int i = cl; i <= T; ++i) A[i] = B[T - i + cl];

    solve(l, mid - , H, cl - );

    solve(mid, r, cl, T);

}

int main() {

    int n = read(), m = read(), mx = , id = , tot = , now = ; bit.n = n;

    for (int i = ; i < n; ++i) {

        int u = read(), v = read();

        add_edge(u, v);

    }

    dfs();

    for (int i = ; i <= m; ++i) {

        int opt = read();

        if (opt == ) {

            int u = read(), v = read(), w = read(), z = LCA(u, v);

            A[i] = (Data){opt, u, v, w, z};

            mx = max(mx, w);

        } else if (opt == ) {

            int t = read();

            A[i] = A[t]; A[i].ty = ;

        } else if (opt == ) {

            int x = read(); ++id;

            A[i] = (Data){, x, id, , };

        }

    }

    for (int i = ; i <= m; ++i) {

        if (A[i].ty <= ) add(A[i], A[i].ty), now += (A[i].ty ? - : ), B[++tot] = A[i];

        else {

            if (bit.Ask(dfn[A[i].a], dfn[A[i].a] + siz[A[i].a] - ) == now) ans[A[i].b] = -;

            else B[++tot] = A[i];

        }

    }

    for (int i = ; i <= tot; ++i) A[i] = B[i];

    bit.clear();

    solve(-, mx, , tot);

    for (int i = ; i <= id; ++i) printf("%d\n", ans[i]);

    return ;

}