#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <cmath>

#include <algorithm>

#include <assert.h>

#define IOS ios::sync_with_stdio(false)

using namespace std;

#define inf (0x3f3f3f3f)

typedef long long int LL;

#include <iostream>

#include <sstream>

#include <vector>

#include <set>

#include <map>

#include <queue>

#include <string>

const int maxn = 2e5 + ;

int col[maxn];

struct node {

    int u, v;

    int tonext;

}e[maxn];

int first[maxn];

int num;

void add(int u, int v) {

    ++num;

    e[num].u = u;

    e[num].v = v;

    e[num].tonext = first[u];

    first[u] = num;

}

int tot[maxn];

int lentot;

int dp[maxn];

struct bfsnode {

    int cur, cnt;

    bfsnode(int a, int b) : cur(a), cnt(b) {}

};

queue<struct bfsnode>que;

bool vis[maxn];

void bfs() {

    memset(vis, false, sizeof vis);

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

        que.push(bfsnode(tot[i], ));

        dp[tot[i]] = ;

    }

    while (!que.empty()) {

        struct bfsnode t = que.front();

        que.pop();

        for (int i = first[t.cur]; i; i = e[i].tonext) {

            int v = e[i].v;

            if (vis[v]) continue;

            if (dp[v] <= t.cnt + ) continue;

            vis[v] = true;

            dp[v] = t.cnt + ;

            que.push(bfsnode(v, t.cnt + ));

        }

    }

}

int ansc[maxn][], deep[maxn], fa[maxn];

void init_LCA(int cur) {

    ansc[cur][] = fa[cur]; //跳1步，那么祖先就是爸爸

    for (int i = ; i <= ; ++i) { //倍增思路，递归处理

        ansc[cur][i] = ansc[ansc[cur][i - ]][i - ];

    }

    for (int i = first[cur]; i; i = e[i].tonext) {

        int v = e[i].v;

        if (v == fa[cur]) continue;

        fa[v] = cur;

        deep[v] = deep[cur] + ;

        init_LCA(v);

    }

}

int LCA(int x, int y) {

    if (deep[x] < deep[y]) swap(x, y); //需要x是最深的

    for (int i = ; i >= ; --i) { //从大到小枚举，因为小的更灵活

        if (deep[ansc[x][i]] >= deep[y]) { //深度相同，走进去就对了。

            x = ansc[x][i];

        }

    }

    if (x == y) return x;

    for (int i = ; i >= ; --i) {

        if (ansc[x][i] != ansc[y][i]) { //走到第一个不等的地方，

            x = ansc[x][i];

            y = ansc[y][i];

        }

    }

    return ansc[x][]; //再跳一步就是答案

}

int dis[maxn];

void dfs(int cur, int step) {

    dis[cur] = min(dis[cur], step);

    for (int i = first[cur]; i; i = e[i].tonext) {

        int v = e[i].v;

        if (vis[v]) continue;

        vis[v] = true;

        dfs(v, step + );

    }

}

void work() {

    int n, m;

    scanf("%d%d", &n, &m);

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

        int u, v;

        scanf("%d%d", &u, &v);

        add(u, v);

        add(v, u);

    }

    memset(dis, 0x3f, sizeof dis);

    dis[] = ;

    vis[] = true;

    dfs(, );

    memset(dp, 0x3f, sizeof dp);

    col[] = ;

    tot[++lentot] = ;

    bfs();

    lentot = ;

    fa[] = ;

    deep[] = ;

    init_LCA();

    int magic = (int)sqrt(m);

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

        int flag, which;

        scanf("%d%d", &flag, &which);

        if (flag == ) {

            tot[++lentot] = which;

        } else {

            int ans = dp[which];

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

                int haha = LCA(which, tot[i]);

                ans = min(ans, dis[which] + dis[tot[i]] -  * dis[haha]);

            }

            printf("%d\n", ans);

        }

        if (lentot >= magic) {

            bfs();

            lentot = ;

        }

    }

}

int main() {

#ifdef local

    freopen("data.txt", "r", stdin);

//    freopen("data.txt", "w", stdout);

#endif

    work();

    return ;

}