#include <iostream>

#include <cstdio>

#include <algorithm>

#include <cmath>

using namespace std;

const int N = 1e6 + ;

#define yxy getchar()

#define lson jd << 1

#define rson jd << 1 | 1

int n, Q, now = , tim, w1, w2, w3;

int head[N], Num[N], deep[N], fa[N], lnum[N], rnum[N], son[N], topp[N], siz[N], tree[N], g_min[N << ];

struct Node{int u, v, nxt;} G[N << ];

inline int read(){

    int x = ; char c = yxy;

    while(c < '' || c > '') c = yxy;

    while(c >= '' && c <= '') x = x *  + c - '', c = yxy;

    return x;

}

inline void add(int u, int v){

    G[now].u = u; G[now].v = v; G[now].nxt = head[u]; head[u] = now ++;

}

void dfs_1(int u, int father, int dep){

    fa[u] = father;

    deep[u] = dep;

    siz[u] = ;

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

        int v = G[i].v;

        if(v != father){

            dfs_1(v, u, dep + );

            siz[u] += siz[v];

            if(siz[v] > siz[son[u]]) son[u] = v;

        }

    }

}

void dfs_2(int u, int tp){

    topp[u] = tp;

    lnum[u] = ++ tim;

    tree[u] = tim;

    Num[tim] = u;

    if(!son[u]) {rnum[u] = tim; return ;}

    dfs_2(son[u], tp);

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

        int v = G[i].v;

        if(v != fa[u] && v != son[u]) dfs_2(v, v);

    }

    rnum[u] = tim;

}

void Poi_A(int l, int r, int jd, int x){

    if(l == r) {

        if(g_min[jd]) w1 = ;

        return ;

    }

    if(g_min[jd]) {

        g_min[lson] = g_min[jd];

        g_min[rson] = g_min[jd];

    }

    int mid = (l + r) >> ;

    if(x <= mid) Poi_A(l, mid, lson, x);

    else Poi_A(mid + , r, rson, x);

}

void Sec_G(int l, int r, int jd, int x, int y, int yg){

    if(x <= l && r <= y){

        g_min[jd] = yg;

        return ;

    }

    int mid = (l + r) >> ;

    if(x <= mid) Sec_G(l, mid, lson, x, y, yg);

    if(y > mid)  Sec_G(mid + , r, rson, x, y, yg);

}

int calc_lca(int x, int y){

    int tp1 = topp[x], tp2 = topp[y];

    while(tp1 != tp2){

        if(deep[tp1] < deep[tp2]) swap(tp1, tp2), swap(x, y);

        x = fa[tp1];

        tp1 = topp[x];

    }

    return deep[x] > deep[y] ? y : x;

}

void Sec_A(int l, int r, int jd, int x, int y){

    if(x <= l && r <= y){

        w2 = g_min[jd];

        return ;

    }

    if(g_min[jd]) {

        g_min[lson] = g_min[jd];

        g_min[rson] = g_min[jd];

    }

    int mid = (l + r) >> ;

    if(x <= mid) Sec_A(l, mid, lson, x, y);

    if(y > mid)  Sec_A(mid + , r, rson, x, y);

}

int get_answer(int l, int r, int x){

    int L = l, R = r, ret;

    while(L <= R){

        int mid = (L + R) >> ;

        if(Num[mid] <= x) L = mid + , ret = mid;

        else R = mid - ;

    }

    return ret - l;

}

int main()

{

    n = read(); Q = read();

    for(int i = ; i <= n; i ++) head[i] = -;

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

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

        add(u, v); add(v, u);

    }

    dfs_1(, , );

    dfs_2(, );

    while(Q --){

        int opt = read();

        if(opt == ){

            int x = read();

            if(!son[x]) continue ;

            w1 = ;

            Poi_A(, n, , tree[x]);

            if(w1) continue ;

            Sec_G(, n, , lnum[x], rnum[x], x);

            sort(Num + lnum[x] + , Num + rnum[x] + );

        }

        else if(opt == ){

            int x = read(), y = read();

            int Lca_now = calc_lca(x, y);

            w1 = ;

            Poi_A(, n, , tree[Lca_now]);

            if(w1) printf("%d\n", min(x, y));

            else printf("%d\n", Lca_now);

        }

        else {

            int x = read();

            w1 = ;

            Poi_A(, n, , tree[x]);

            if(!w1) printf("%d\n", deep[x]);

            else {

                Sec_A(, n, , lnum[x], rnum[x]);

                printf("%d\n", get_answer(lnum[w2], rnum[w2], x) + deep[w2]);

            }

        }

    }

    return ;

}