#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

//#define OFFLINE

#define F cin
#define G cout

const int N = 100010;

int n,m,first[N],euler[N<<2],aint[N<<4],l,root=1,lvl[N];
vector<int> v[N];

void parc(int x,int d)
{
    euler[++l] = x;
    first[x] = l;
    lvl[x] = lvl[d] + 1;
    for (int i=0;i<int(v[x].size());++i)
    {
        int y = v[x][i];
        if ( y != d )
        {
            parc(y,x);
            euler[++l] = x;
        }
    }
}

void build(int n,int l,int r)
{
    if ( l == r )
    {
        aint[n] = euler[l];
        return;
    }
    int m = (l + r) / 2;

    build(n*2,l,m);
    build(n*2+1,m+1,r);

    aint[n] = min(aint[n*2],aint[n*2+1]);
}

int ask(int n,int l,int r,int il,int ir)
{
    if ( il > r || ir < l ) return 1<<30;
    if ( il <= l && r <= ir ) return aint[n];

    int m = (l + r) / 2;
    int qa = ask(n*2,l,m,il,ir);
    int qb = ask(n*2+1,m+1,r,il,ir);

    return min(qa,qb);
}

int lca(int x,int y)
{
    int lt = first[x];
    int rt = first[y];
    if ( lt > rt ) swap(lt,rt);
    return ask(1,1,l,lt,rt);
}

int solve(int x,int y,int r)
{
    int x_r = lca(x,r);
    int y_r = lca(y,r);
    int x_y = lca(x,y);

    int ans = x_r;
    if ( lvl[ans] < lvl[y_r] )
        ans = y_r;
    if ( lvl[ans] < lvl[x_y] )
        ans = x_y;
    if ( ans == x || ans == y )
        ans = -1;
    return ans;
}

int main()
{
    ios::sync_with_stdio(0);
    #ifdef OFFLINE
        ifstream F("lca.in");
        ofstream G("lca.out");
    #endif

    F>>n>>m;
    for (int i=1,x,y;i<n;++i)
    {
        F>>x>>y;
        v[x].push_back(y);
        v[y].push_back(x);
    }
    parc(1,0);
    build(1,1,l);
    for (int i=1,t,x,y;i<=m;++i)
    {
        F>>t;
        if ( t == 1 )
        {
            F>>x;
            root = x;
        }
        else
        {
            F>>x>>y;
            G<<solve(x,y,root)<<'\n';
        }
    }
}