//First one Was Copy
#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=22000,inf=1e9+10;

//#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[a][i]!=-1&&h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	cin>>n>>m;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			cout<<ANS<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=24;
	}
}


//First one Was Copy
#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=70,inf=1e9+10;

//#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[a][i]!=-1&&h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	//cin>>n>>m;
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			//cout<<ANS<<endl;
			printf("%d\n",ANS);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=41;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=30;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=13;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=320,inf=1e9+10;

//#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	//memset(dp,inf,mxmx);
	for(int i=0;i<mxmx;i++)dp[i]=inf;
	//memset(par,-1,mxmx*lgn);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[a][i]!=-1&&h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret-=2*h[a];
	if(ret<0)cout<<"YOU HAVE BUG HERE"<<endl;
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	cin>>n>>m;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			cout<<ANS<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=3;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20;

#define mp make_pair

int n,m;
vector <int>adj[mxmx];
struct vertex{
	int moalefe;
	int start_t,end_t;//
	int start,end;
	int dp;//
	int h;//
	int par[lgn];//
	vertex(){
		for(int i=0;i<lgn;i++)par[i]=-1;
	}
};
struct moalefe_b{
	int baba;
};
moalefe_b l[mxmx];
vertex ver[mxmx];
int moal=0,TIME=0;
vector<pair<int,int> >poop;
void dfs(int v){
	int next;
	ver[v].start_t=TIME;
	ver[v].start=poop.size();
	poop.push_back(mp(TIME,v));
	TIME++;
	for(int i=1;i<lgn;i++){
		if(ver[v].par[i-1]!=-1)ver[v].par[i]=ver[ver[v].par[i-1]].par[i-1];
		else ver[v].par[i]=-1;
	}
	for(int i=0;i<adj[v].size();i++){
		next=adj[v][i];
		if(next!=ver[v].par[0]){
			ver[next].h=ver[v].h+1;
			ver[next].par[0]=v;
			dfs(next);
			TIME++;
			ver[v].dp+=ver[next].dp;
		}
	}
	ver[v].dp++;
	ver[v].end_t=TIME;
	ver[v].end=poop.size();
	poop.push_back(mp(TIME,v));
}
int LCA(int a,int b){
	if(ver[a].h<ver[b].h)swap(a,b);
	while(ver[a].h>ver[b].h){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[ver[a].par[i]].h>=ver[b].h){
					a=ver[a].par[i];
					break;
				}
			}
		}
	}
	while(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[a].par[i]!=ver[b].par[i]){
					a=ver[a].par[i];
					b=ver[b].par[i];
				}
			}
		}
	}
	if(a!=b){
		a=ver[a].par[0];
	}
	return a;
}
int test(int fasele,int a){
	int b=ver[a].h-fasele;
	while(ver[a].h!=b){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[ver[a].par[i]].h>=b){
					a=ver[a].par[i];
				}
			}
		}
	}
	return a;
}
void unmerge(int mid,int b,int baba,int lca){
	int dp1,dp2;
	dp1=ver[mid].dp;
	dp2=ver[lca].dp-dp1;
		for(int i=ver[b].start;i!=ver[b].end;i++){
			ver[poop[i].second].moalefe=moal;
		}
		l[moal].baba=b;
		moal++;
}
int main(){
	//ios::sync_with_stdio(0);cin.tie(0);
	cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		cin>>u>>v;
		u--;
		v--;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	for(int i=0;i<n;i++){
		ver[i].moalefe=moal;
	}
	l[moal].baba=0;
	moal++;
	dfs(0);
	/*for(int i=0;i<n;i++){
		cout<<i+1<<endl;
		cout<<"moalefe"<<" "<<ver[i].moalefe<<endl;
		cout<<"TIME: "<<ver[i].start_t<<" "<<ver[i].end_t<<endl;
		cout<<"dp "<<ver[i].dp<<endl;
		cout<<"h "<<ver[i].h<<endl;
		cout<<"par"<<endl;
		for(int j=0;j<lgn;j++){
			cout<<j<<" ";
		}
		cout<<endl;
		for(int j=0;j<lgn;j++){
			cout<<ver[i].par[j]+1<<" ";
		}
		cout<<endl;
		cout<<"-----------------"<<endl;
	}*/
	int lca,baba,fasele,mid;
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==2){
			baba=l[ver[b].moalefe].baba;
			lca=LCA(b,baba);
			fasele=ver[b].h-ver[lca].h+ver[baba].h-ver[lca].h;
			cout<<fasele<<endl;
		}
		else{
			baba=l[ver[b].moalefe].baba;
			lca=LCA(b,baba);
			fasele=ver[b].h-ver[lca].h+ver[baba].h-ver[lca].h;
			fasele/=2;
			mid=test(fasele,b)+1;
			unmerge(mid,b,baba,lca);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9+10,lg=20;
int n,m;
vector<int>adj[mxmx];
vector<int>vers;
int h[mxmx],par[lg][mxmx];
void dfs(int ver){
    int next;
    if(par[0][ver]!=-1)h[ver]=h[par[0][ver]]+1;
    for(int i=1;i<lg;i++){
        if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
        else par[i][ver]=-1;
    }
    for(int i=0;i<adj[ver].size();i++){
        next=adj[ver][i];
        if(next!=par[0][ver]){
            par[0][next]=ver;
            dfs(next);
        }
    }
}
int LCA(int a,int b){
    if(h[a]<h[b])swap(a,b);
    for(int i=lg-1;i>=0;i--){
        if(par[i][a]!=-1){
            if(h[par[i][a]]>=h[b]){
                a=par[i][a];
            }
        }
    }
    for(int i=lg-1;i>=0;i--){
        if(par[i][a]!=-1){
            if(par[i][a]!=par[i][b]){
                a=par[i][a];
                b=par[i][b];
            }
        }
    }
    if(a!=b){
        a=par[0][a];
        b=par[0][b];
    }
    return a;
}
int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    scanf("%d %d",&n,&m);
    //cin>>n>>m;
    for(int i=1,u,v;i<n;i++){
        scanf("%d %d",&u,&v);
        //cin>>u>>v;
        u--;
        v--;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    par[0][0]=-1;
    dfs(0);
    vers.push_back(0);
    int lca,ANS;
    for(int i=0,a,b;i<m;i++){

        scanf("%d %d",&a,&b);
//        cin>>a>>b;
        b--;
        ANS=inf;
        if(a==2){
            for(int i=0;i<vers.size();i++){
                lca=LCA(b,vers[i]);
                ANS=min(ANS,h[vers[i]]-2*h[lca]+h[b]);
            }
            printf("%d \n",ANS);
            //cout<<ANS<<endl;
        }
        else{
            vers.push_back(b);
        }
    }
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
deque<pair<int,int> >poop;
vector<int>red;
inline void bfs(){
	int v,next,fasele;
	while(poop.size()!=0){
		v=poop.front().first;
		fasele=poop.front().second;
		poop.pop_front();
		if(dp[v]<=fasele)continue;
		dp[v]=fasele;
		for(int j=0;j<adj[v].size();j++){
			poop.push_back(mp(adj[v][j],fasele+1));
		}
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//cin>>n>>m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	red.push_back(0);
	poop.push_back(mp(0,0));
	bfs();
	for(int i=0,a,b;i<m;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		b--;
		if(a==1){
			red.push_back(b);
			poop.push_back(mp(b,0));
			//bfs(b);
		}
		else{
			//cout<<dp[b]<<'\n';
			if(red.size()!=0){
				bfs();
				red.clear();
				poop.clear();
			}
			printf("%d\n",dp[b]);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=25;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=44;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
vector<pair<int,int> >poop;
bool visited[mxmx];
void bfs(int ver){
	poop.clear();
	poop.push_back(mp(ver,0));
	dp[ver]=0;
	visited[ver]=1;
	int v,next,fasele;
	for(int i=0;i<poop.size();i++){
		v=poop[i].first;
		fasele=poop[i].second;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			if(dp[next]>fasele+1&&visited[next]==0){
				dp[next]=fasele+1;
				visited[next]=1;
				poop.push_back(mp(next,fasele+1));
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//cin>>n>>m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	memset(visited,0,mxmx);
	bfs(0);
	for(int i=0,a,b;i<m;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		b--;
		if(a==1){
			memset(visited,0,mxmx);
			bfs(b);
		}
		else{
			//cout<<dp[b]<<'\n';
			printf("%d\n",dp[b]);
		}
	}
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <vector>
#include <queue>
#define FOR(i,a,b) for(int i=a,_b=b;i<=_b;i++)
#define FO(i,a,b) for(int i=a,_b=b;i<_b;i++)
#define FORD(i,a,b) for(int i=a,_b=b;i>=_b;i--)
#define FOD(i,a,b) for(int i=a,_b=b;i>_b;i--)
#define FORV(i, a) for(typeof(a.begin())i=a.begin();i!=a.end();i++)
#define LL long long

using namespace std;

int n, m;
vector<int> adj[100001];

void input(){
    scanf("%d%d", &n, &m);
    int u, v;
    FO (i, 1, n){
        scanf("%d%d", &u, &v);
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
}

queue<int> q1, q2;
bool vs[100001];
int d[100001];
vector<int> redNode;

void bfs(){
    FO (i, 0, redNode.size()){
        q1.push(redNode[i]);
        q2.push(0);
    }
    int u, dist;
    while (!q1.empty()){
        u = q1.front();
        dist = q2.front();
        q1.pop();
        q2.pop();
        if (d[u] <= dist) continue;
        d[u] = dist;
        FO (i, 0, adj[u].size()){
            q1.push(adj[u][i]);
            q2.push(dist+1);
        }
    }
}

void process(){
    fill(&d[1], &d[n+1], 1e6);
    redNode.push_back(1);
    int t, v;
    redNode.push_back(1);
    FOR (i, 1, m){
        scanf("%d%d", &t, &v);
        if (t == 1){
            redNode.push_back(v);
        }
        else{
            bfs();
            redNode.clear();
            printf("%d\n", d[v]);
        }
    }
}

int main(){
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    input();
    process();
    return 0;
}


//First one Was Copy
#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=5000,inf=1e9+10;

//#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[a][i]!=-1&&h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	cin>>n>>m;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			cout<<ANS<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
vector<pair<int,int> >poop;
int I=0;
void bfs(int ver){
	poop.push_back(mp(ver,0));
	dp[ver]=0;
	int v,next,fasele;
	for(int i=poop.size()-1;i<poop.size();i++){
		v=poop[i].first;
		fasele=poop[i].second;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			if(dp[next]>fasele+1){
				dp[next]=fasele+1;
				poop.push_back(mp(next,fasele+1));
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	cin>>n>>m;
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	bfs(0);
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			bfs(b);
		}
		else{
			cout<<dp[b]<<'\n';
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=320,inf=1e9+10;

#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	//memset(dp,inf,mxmx);
	for(int i=0;i<mxmx;i++)dp[i]=inf;
	//memset(par,-1,mxmx*lgn);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int A,B;
	A=a;
	B=b;
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	return h[B]-h[a]+h[A]-h[a];
}

int32_t main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	cin>>n>>m;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			cout<<ANS<<endl;
		}
	}
}


#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstdlib>

using namespace std;

struct NODE{ int v, d; };

vector<int> G[100001];
int n, m, D[100001], sz[100001];
queue<NODE> Q;
void red(int v)
{
    NODE t;
    while(!Q.empty())
    {
        t = Q.front(); Q.pop();
        for(int i = 0 ; i < sz[t.v] ; i++ )
            if(  D[G[t.v][i]] > D[t.v]+1 ) D[G[t.v][i]] = t.d+1, Q.push({G[t.v][i], t.d+1});
    }
}

int main()
{
    int i, p, c;
    scanf("%d%d",&n,&m);
    for( i = 1 ; i < n ; i++ )
        scanf("%d%d",&p,&c), G[p].push_back(c), G[c].push_back(p), sz[p]++, sz[c]++, D[i] = 1<<30; D[i] = 1<<30;
    Q.push({1,0});
    D[1] = 0;
    red(1);
    for( i = 0 ; i < m ; i++ )
    {
        scanf("%d%d",&p,&c);
        if( p == 1 )
            Q.push({c,0}), D[c] = 0;
        else
            red(c), printf("%d\n", D[c]);
    }
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=15;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=43;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=29;
	}
}


#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#define REP(i,m) for(int i=0;i<m;++i)
#define REPN(i,m,in) for(int i=in;i<m;++i)
#define ALL(t) (t).begin(),(t).end()
#define pb push_back
#define mp make_pair
#define fr first
#define sc second
#define dump(x)  cerr << #x << " = " << (x) << endl
#define prl cerr<<"called:"<< __LINE__<<endl
using namespace std;
static const int INF =500000000;
template<class T> void debug(T a,T b){ for(;a!=b;++a) cerr<<*a<<' ';cerr<<endl;}
typedef long long int lint;
typedef pair<int,int> pi;

int n,m;
vector<int> g[100005];
const int B=300;

int newvs[1005];
int mark[100005];
int cost[100005];
void bfs(){
    memset(cost,-1,sizeof(cost));
    queue<int> q;
    REP(i,n) if(mark[i]){
        cost[i]=0;
        q.push(i);
    }
    while(!q.empty()){
        int cur=q.front();q.pop();
        REP(i,g[cur].size()){
            int to=g[cur][i];
            if(cost[to]!=-1) continue;
            cost[to]=cost[cur]+1;
            q.push(to);
        }
    }
}
int par[20][100005];
int dep[100005];
void dfs(int v,int p,int d){
    par[0][v]=p;
    dep[v]=d;
    REP(i,g[v].size()){
        int to=g[v][i];
        if(to==p) continue;
        dfs(to,v,d+1);
    }
}

int lca(int a,int b){
    if(dep[a]>dep[b]) swap(a,b);
    int dif=dep[b]-dep[a];
    REP(i,20) if(dif>>i&1) b=par[i][b];
    if(a==b) return a;
    for(int i=19;i>=0;--i) if(par[i][a]!=par[i][b]){
        a=par[i][a];b=par[i][b];
    }
    return par[0][a];
}

int getdist(int a,int b){
    return dep[a]+dep[b]-dep[lca(a,b)]*2;
}
int solve(int v,int m){
    int res=cost[v];
    REP(i,m){
        res=min(res,getdist(newvs[i],v));
    }
    return res;
}

int main(){
    cin>>n>>m;
    REP(i,n-1){
        int a,b;cin>>a>>b;--a;--b;
        g[a].pb(b);
        g[b].pb(a);
    }
    dfs(0,-1,0);
    REP(i,19) REP(j,n){
        if(par[i][j]==-1) par[i+1][j]=-1;
        else par[i+1][j]=par[i][par[i][j]];
    }

    mark[0]=1;
    for(int st=0;st<m;st+=B){
        int cnt=0;
        bfs();
        for(int i=st;i<min(m,st+B);++i){
            int t,v;scanf("%d%d",&t,&v);--v;
            if(t==1) newvs[cnt++]=v,mark[v]=1;
            else printf("%d\n",solve(v,cnt));
        }
    }
    int khanj=0;
    for(int i=100000;i>=0;i--)
        khanj=i;
    return khanj;
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=27;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
deque<pair<int,int> >poop;
vector<int>red;
void bfs(){
	poop.clear();
	for(int i=0;i<red.size();i++){
		poop.push_back(mp(red[i],0));
	}
	int v,next,fasele;
	while(poop.size()!=0){
		v=poop.front().first;
		fasele=poop.front().second;
		poop.pop_front();
		if(dp[v]<=fasele)continue;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			poop.push_back(mp(next,fasele+1));
		}
		dp[v]=fasele;
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//cin>>n>>m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	red.push_back(0);
	bfs();
	for(int i=0,a,b;i<m;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		b--;
		if(a==1){
			red.push_back(b);
			//bfs(b);
		}
		else{
			//cout<<dp[b]<<'\n';
			if(red.size()!=0){
				bfs();
			}
			printf("%d\n",dp[b]);
			red.clear();
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[a][i]!=-1&&h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=37;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=16;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=12;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=9;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
deque<pair<int,int> >poop;
void bfs(int ver){
	poop.push_back(mp(ver,0));
	dp[ver]=0;
	int v,next,fasele;
	for(int i=0;i<poop.size();i++){
		v=poop[i].first;
		fasele=poop[i].second;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			if(dp[next]>fasele+1){
				dp[next]=fasele+1;
				poop.push_back(mp(next,fasele+1));
			}
		}
	}
	poop.pop_front();
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);
	cin>>n>>m;
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	bfs(0);
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			bfs(b);
		}
		else{
			cout<<dp[b]<<endl;
		}
	}
}


//First one Was Copy
#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=70,inf=1e9+10;

//#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[a][i]!=-1&&h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	cin>>n>>m;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			cout<<ANS<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=48;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20;

#define mp make_pair

int n,m;
vector <int>adj[mxmx];
struct vertex{
	int moalefe;
	int start_t,end_t;//
	int start,end;
	int dp;//
	int h;//
	int par[lgn];//
	vertex(){
		for(int i=0;i<lgn;i++)par[i]=-1;
	}
};
struct moalefe_b{
	int baba;
};
moalefe_b l[mxmx];
vertex ver[mxmx];
int moal=0,TIME=0;
vector<pair<int,int> >poop;
void dfs(int v){
	int next;
	ver[v].start_t=TIME;
	ver[v].start=poop.size();
	poop.push_back(mp(TIME,v));
	TIME++;
	for(int i=1;i<lgn;i++){
		if(ver[v].par[i-1]!=-1)ver[v].par[i]=ver[ver[v].par[i-1]].par[i-1];
		else ver[v].par[i]=-1;
	}
	for(int i=0;i<adj[v].size();i++){
		next=adj[v][i];
		if(next!=ver[v].par[0]){
			ver[next].h=ver[v].h+1;
			ver[next].par[0]=v;
			dfs(next);
			TIME++;
			ver[v].dp+=ver[next].dp;
		}
	}
	ver[v].dp++;
	ver[v].end_t=TIME;
	ver[v].end=poop.size();
	poop.push_back(mp(TIME,v));
}
int LCA(int a,int b){
	if(ver[a].h<ver[b].h)swap(a,b);
	while(ver[a].h>ver[b].h){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[ver[a].par[i]].h>=ver[b].h){
					a=ver[a].par[i];
					break;
				}
			}
		}
	}
	while(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[a].par[i]!=ver[b].par[i]){
					a=ver[a].par[i];
					b=ver[b].par[i];
				}
			}
		}
	}
	if(a!=b){
		a=ver[a].par[0];
	}
	return a;
}
int test(int fasele,int a){
	int b=ver[a].h-fasele;
	while(ver[a].h!=b){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[ver[a].par[i]].h>=b){
					a=ver[a].par[i];
				}
			}
		}
	}
	return a;
}
void unmerge(int mid,int b,int baba,int lca){
	int dp1,dp2;
	dp1=ver[mid].dp;
	dp2=ver[lca].dp-dp1;
	if(dp1<dp2){
		for(int i=ver[b].start;i!=ver[b].end;i++){
			ver[poop[i].second].moalefe=moal;
		}
		l[moal].baba=b;
		moal++;
	}
	else{
		swap(ver[baba],ver[b]);
		l[moal].baba=b;
		for(int i=0;i<ver[b].start;i++){
			ver[poop[i].second].moalefe=moal;
		}
		for(int i=ver[b].end;i<poop.size();i++){
			ver[poop[i].second].moalefe=moal;
		}
		moal++;
	}
}
int main(){
	//ios::sync_with_stdio(0);cin.tie(0);
	cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		cin>>u>>v;
		u--;
		v--;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	for(int i=0;i<n;i++){
		ver[i].moalefe=moal;
	}
	l[moal].baba=0;
	moal++;
	dfs(0);
	/*for(int i=0;i<n;i++){
		cout<<i+1<<endl;
		cout<<"moalefe"<<" "<<ver[i].moalefe<<endl;
		cout<<"TIME: "<<ver[i].start_t<<" "<<ver[i].end_t<<endl;
		cout<<"dp "<<ver[i].dp<<endl;
		cout<<"h "<<ver[i].h<<endl;
		cout<<"par"<<endl;
		for(int j=0;j<lgn;j++){
			cout<<j<<" ";
		}
		cout<<endl;
		for(int j=0;j<lgn;j++){
			cout<<ver[i].par[j]+1<<" ";
		}
		cout<<endl;
		cout<<"-----------------"<<endl;
	}*/
	int lca,baba,fasele,mid;
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==2){
			baba=l[ver[b].moalefe].baba;
			lca=LCA(b,baba);
			fasele=ver[b].h-ver[lca].h+ver[baba].h-ver[lca].h;
			cout<<fasele<<endl;
		}
		else{
			baba=l[ver[b].moalefe].baba;
			lca=LCA(b,baba);
			fasele=ver[b].h-ver[lca].h+ver[baba].h-ver[lca].h;
			fasele/=2;
			mid=test(fasele,b)+1;
			unmerge(mid,b,baba,lca);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=2;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=5;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=21;
	}
}


#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<math.h>
#include<stdlib.h>
#include<ctype.h>
using namespace std;

#define X first
#define Y second
typedef pair<int,int> P;

const int MV = 100010;
const int ME = MV<<1;
const int LMV = 18;
const int inf = 1e8;

int st[MV], en[ME], next[ME];
int N, dep[MV], up[MV][LMV], par[MV], dis[MV];
int down[MV];
bool check[MV];
bool cut[ME];

void addedge(int s,int d,int c)
{
    next[c]=st[s];
    st[s]=c;
    en[c]=d;
}

void dfs(int x,int p)
{
    check[x]=down[x]=1;
    for(int i=st[x];i;i=next[i]){
        if(!check[en[i]] && !cut[i])up[en[i]][p] = up[x][p]+1, dfs(en[i],p), down[x]+=down[en[i]];
    }check[x]=0;
}

int find_mid(int x)
{
    int u = down[x]>>1, i;
    for(;;){
        for(i=st[x];i;i=next[i]){
            if(cut[i] || down[x]<down[en[i]])continue;
            if(down[en[i]]>u){x=en[i];break;}
        }
        if(!i)return x;
    }
}

void solve(int x,int pa)
{
    int r = find_mid(x);
    dep[r] = dep[pa]+1;
    par[r] = pa;
    dfs(r,dep[r]);
    for(int i=st[r];i;i=next[i]){
        if(cut[i])continue;
        cut[i] = cut[i^1] = 1;
        solve(en[i],r);
    }
}

void update(int x)
{
    for(int t=x;t;t=par[t])dis[t] = min(dis[t],up[x][dep[t]]);
}

int read(int x)
{
    int ret=inf;
    for(int t=x;t;t=par[t])ret=min(ret,dis[t]+up[x][dep[t]]);
    return ret;
}

void pre()
{
    dfs(1,0);
    solve(1,0);
    for(int i=1;i<=N;i++)dis[i]=inf;
    update(1);
}

int getInt()
{
    int t=0;
    char x=getchar();
    while(isdigit(x)){
        t=(t<<1)+(t<<3)+x-48;
        x=getchar();
    }
    return t;
}

int main()
{
//    freopen("input.txt","r",stdin);
    N=getInt();
    int q=getInt(), i;
    for(i=1;i<N;i++){
        int x=getInt(),y=getInt();
        addedge(x,y,2*i);
        addedge(y,x,2*i+1);
    }
    pre();
    while(q--){
        int cmd=getInt(),x=getInt();
        if(cmd==1)update(x);
        else printf("%d\n",read(x));
    }
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=8;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
vector<pair<int,int> >poop;
int I=0;
void bfs(int ver){
	poop.push_back(mp(ver,0));
	dp[ver]=0;
	int v,next,fasele;
	for(int i=poop.size()-1;i<poop.size();i++){
		v=poop[i].first;
		fasele=poop[i].second;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			if(dp[next]>fasele+1){
				dp[next]=fasele+1;
				poop.push_back(mp(next,fasele+1));
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);
	cin>>n>>m;
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	dp[0]=0;
	bfs(0);
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			bfs(b);
		}
		else{
			cout<<dp[b]<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=47;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9+10,lg=20;
int n,m;
vector<int>adj[mxmx];
vector<int>vers;
int h[mxmx],par[lg][mxmx];
void dfs(int ver){
	int next;
	if(par[0][ver]!=-1)h[ver]=h[par[0][ver]]+1;
	for(int i=1;i<lg;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			dfs(next);
		}
	}
}
int LCA(int a,int b){
	if(h[a]<h[b])swap(a,b);
	for(int i=lg-1;i>=0;i--){
		if(par[i][a]!=-1){
			if(h[par[i][a]]>=h[b]){
				a=par[i][a];
			}
		}
	}
	for(int i=lg-1;i>=0;i--){
		if(par[i][a]!=-1){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
	}
	if(a!=b){
		a=par[0][a];
		b=par[0][b];
	}
	return a;
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	scanf("%d %d",&n,&m);
	//cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		scanf("%d %d",&u,&v);
		//cin>>u>>v;
		u--;
		v--;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	par[0][0]=-1;
	dfs(0);
	vers.push_back(0);
	int lca,ANS;
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		ANS=inf;
		if(a==2){
			for(int i=0;i<vers.size();i++){
				lca=LCA(b,vers[i]);
				ANS=min(ANS,h[vers[i]]-2*h[lca]+h[b]);
			}
			printf("%d \n",ANS);
			//cout<<ANS<<endl;
		}
		else{
			vers.push_back(b);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=39;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
vector<pair<int,int> >poop;
void bfs(int ver){
	poop.clear();
	poop.push_back(mp(ver,0));
	dp[ver]=0;
	int v,next,fasele;
	for(int i=0;i<poop.size();i++){
		v=poop[i].first;
		fasele=poop[i].second;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			if(dp[next]>fasele+1){
				dp[next]=fasele+1;
				poop.push_back(mp(next,fasele+1));
			}
		}
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);
	cin>>n>>m;
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	dp[0]=0;
	bfs(0);
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			bfs(b);
		}
		else{
			cout<<dp[b]<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20;

#define mp make_pair

int n,m;
vector <int>adj[mxmx];
struct vertex{
	int moalefe;
	int start_t,end_t;//
	int start,end;
	int dp;//
	int h;//
	int par[lgn];//
	vertex(){
		for(int i=0;i<lgn;i++)par[i]=-1;
	}
};
struct moalefe_b{
	int baba;
};
moalefe_b l[mxmx];
vertex ver[mxmx];
int moal=0,TIME=0;
vector<pair<int,int> >poop;
void dfs(int v){
	int next;
	ver[v].start_t=TIME;
	ver[v].start=poop.size();
	poop.push_back(mp(TIME,v));
	TIME++;
	for(int i=1;i<lgn;i++){
		if(ver[v].par[i-1]!=-1)ver[v].par[i]=ver[ver[v].par[i-1]].par[i-1];
		else ver[v].par[i]=-1;
	}
	for(int i=0;i<adj[v].size();i++){
		next=adj[v][i];
		if(next!=ver[v].par[0]){
			ver[next].h=ver[v].h+1;
			ver[next].par[0]=v;
			dfs(next);
			TIME++;
			ver[v].dp+=ver[next].dp;
		}
	}
	ver[v].dp++;
	ver[v].end_t=TIME;
	ver[v].end=poop.size();
	poop.push_back(mp(TIME,v));
}
int LCA(int a,int b){
	if(ver[a].h<ver[b].h)swap(a,b);
	while(ver[a].h>ver[b].h){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[ver[a].par[i]].h>=ver[b].h){
					a=ver[a].par[i];
					break;
				}
			}
		}
	}
	while(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[a].par[i]!=ver[b].par[i]){
					a=ver[a].par[i];
					b=ver[b].par[i];
				}
			}
		}
	}
	if(a!=b){
		a=ver[a].par[0];
	}
	return a;
}
int test(int fasele,int a){
	int b=ver[a].h-fasele;
	while(ver[a].h!=b){
		for(int i=lgn-1;i>=0;i--){
			if(ver[a].par[i]!=-1){
				if(ver[ver[a].par[i]].h>=b){
					a=ver[a].par[i];
				}
			}
		}
	}
	return a;
}
void unmerge(int mid,int b,int baba,int lca){
	int dp1,dp2;
	dp1=ver[mid].dp;
	dp2=ver[lca].dp-dp1;
	for(int i=ver[b].start;i!=ver[b].end;i++){
		if(ver[poop[i].second].moalefe==ver[baba].moalefe)ver[poop[i].second].moalefe=moal;
	}
	l[moal].baba=b;
	moal++;
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		cin>>u>>v;
		u--;
		v--;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	for(int i=0;i<n;i++){
		ver[i].moalefe=moal;
	}
	l[moal].baba=0;
	moal++;
	dfs(0);
	/*for(int i=0;i<n;i++){
		cout<<i+1<<endl;
		cout<<"moalefe"<<" "<<ver[i].moalefe<<endl;
		cout<<"TIME: "<<ver[i].start_t<<" "<<ver[i].end_t<<endl;
		cout<<"dp "<<ver[i].dp<<endl;
		cout<<"h "<<ver[i].h<<endl;
		cout<<"par"<<endl;
		for(int j=0;j<lgn;j++){
			cout<<j<<" ";
		}
		cout<<endl;
		for(int j=0;j<lgn;j++){
			cout<<ver[i].par[j]+1<<" ";
		}
		cout<<endl;
		cout<<"-----------------"<<endl;
	}*/
	int lca,baba,fasele,mid;
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==2){
			baba=l[ver[b].moalefe].baba;
			lca=LCA(b,baba);
			fasele=ver[b].h-ver[lca].h+ver[baba].h-ver[lca].h;
			cout<<fasele<<endl;
		}
		else{
			baba=l[ver[b].moalefe].baba;
			lca=LCA(b,baba);
			fasele=ver[b].h-ver[lca].h+ver[baba].h-ver[lca].h;
			fasele/=2;
			mid=test(fasele,b)+1;
			unmerge(mid,b,baba,lca);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=7;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9+10,lg=20;
int n,m;
vector<int>adj[mxmx];
vector<int>vers;
int h[mxmx],par[lg][mxmx];
void dfs(int ver){
	int next;
	if(par[0][ver]!=-1)h[ver]=h[par[0][ver]]+1;
	for(int i=1;i<lg;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			dfs(next);
		}
	}
}
int LCA(int a,int b){
	if(h[a]<h[b])swap(a,b);
	for(int i=lg-1;i>=0;i--){
		if(par[i][a]!=-1){
			if(h[par[i][a]]>=h[b]){
				a=par[i][a];
			}
		}
	}
	for(int i=lg-1;i>=0;i--){
		if(par[i][a]!=-1){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
	}
	if(a!=b){
		a=par[0][a];
		b=par[0][b];
	}
	return a;
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	cin>>n>>m;
	for(int i=1,u,v;i<n;i++){
		cin>>u>>v;
		u--;
		v--;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}
	par[0][0]=-1;
	dfs(0);
	vers.push_back(0);
	int lca,ANS;
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		ANS=inf;
		if(a==2){
			for(int i=0;i<vers.size();i++){
				lca=LCA(b,vers[i]);
				ANS=min(ANS,h[vers[i]]-2*h[lca]+h[b]);
			}
			cout<<ANS<<endl;
		}
		else{
			vers.push_back(b);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=36;
	}
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <string.h>
#include <vector>
#include <queue>
#define FOR(i,a,b) for(int i=a,_b=b;i<=_b;i++)
#define FO(i,a,b) for(int i=a,_b=b;i<_b;i++)
#define FORD(i,a,b) for(int i=a,_b=b;i>=_b;i--)
#define FOD(i,a,b) for(int i=a,_b=b;i>_b;i--)
#define FORV(i, a) for(typeof(a.begin())i=a.begin();i!=a.end();i++)
#define LL long long

using namespace std;

int n, m;
vector<int> adj[100001];

void input(){
    scanf("%d%d", &n, &m);
    int u, v;
    FO (i, 1, n){
        scanf("%d%d", &u, &v);
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
}

queue<int> q1, q2;
bool vs[100001];
int d[100001];
vector<int> redNode;

void bfs(){
    FO (i, 0, redNode.size()){
        q1.push(redNode[i]);
        q2.push(0);
    }
    int u, dist;
    while (!q1.empty()){
        u = q1.front();
        dist = q2.front();
        q1.pop();
        q2.pop();
        if (d[u] <= dist){}
        else d[u] = dist;
        FO (i, 0, adj[u].size()){
            q1.push(adj[u][i]);
            q2.push(dist+1);
        }
    }
}

void process(){
    fill(&d[1], &d[n+1], 1e6);
    redNode.push_back(1);
    int t, v;
    redNode.push_back(1);
    FOR (i, 1, m){
        scanf("%d%d", &t, &v);
        if (t == 1){
            redNode.push_back(v);
        }
        else{
            bfs();
            redNode.clear();
            printf("%d\n", d[v]);
        }
    }
}

int main(){
    //freopen("test.in", "r", stdin);
    //freopen("test.out", "w", stdout);
    input();
    process();
    return 0;
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9;

#define mp make_pair

int n,m;
vector<int>adj[mxmx];
int dp[mxmx];
vector<pair<int,int> >poop;
bool visited[mxmx];
void bfs(int ver){
	poop.clear();
	poop.push_back(mp(ver,0));
	visited[ver]=1;
	int v,next,fasele;
	for(int i=0;i<poop.size();i++){
		v=poop[i].first;
		fasele=poop[i].second;
		if(dp[v]<=fasele)continue;
		for(int j=0;j<adj[v].size();j++){
			next=adj[v][j];
			if(dp[next]>fasele+1&&visited[next]==0){
				visited[next]=1;
				poop.push_back(mp(next,fasele+1));
			}
		}
		dp[v]=fasele;
	}
}
int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	//cin>>n>>m;
	scanf("%d %d",&n,&m);
	for(int i=0;i<n;i++)dp[i]=inf;
	for(int i=1,a,b;i<n;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	memset(visited,0,mxmx);
	bfs(0);
	for(int i=0,a,b;i<m;i++){
		//cin>>a>>b;
		scanf("%d %d",&a,&b);
		b--;
		if(a==1){
			memset(visited,0,mxmx);
			bfs(b);
		}
		else{
			//cout<<dp[b]<<'\n';
			printf("%d\n",dp[b]);
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=4;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=11;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=26;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+1,lgn=17,V_=77,inf=1e9+10;

#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[lgn][mxmx];
int h[mxmx];
//ANS
int ANS;
int lca;

inline void pre(){
	fill(dp,dp+mxmx,inf);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[j][i]=-1;
		}
	}
}

inline void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

inline void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
		else par[i][ver]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[0][ver]){
			par[0][next]=ver;
			pre_dfs(next,H+1);
		}
	}
}

inline int LCA(int a,int b){
	int ret;
	ret=h[a]+h[b];
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(par[i][a]!=-1&&h[par[i][a]]>=h[b]){
			a=par[i][a];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[i][a]!=par[i][b]){
				a=par[i][a];
				b=par[i][b];
			}
		}
		a=par[0][a];
		b=par[0][b];
	}
	ret-=2*h[a];
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	scanf("%d %d",&n,&m);
	for(int i=1,a,b;i<n;i++){
		scanf("%d %d",&a,&b);
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		scanf("%d %d",&a,&b);
		b--;

		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			printf("%d\n",ANS);
		}
	}
	if(1==1){
		n=49;
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,lgn=20,V_=320,inf=1e9+10;

//#define int long long
#define mp make_pair
#define X first
#define Y second

//MAIN
int n,m;
vector<int>adj[mxmx];
vector<pair<int,int> >red;
int dp[mxmx];
//LCA
int par[mxmx][lgn];
int h[mxmx];
//ANS
int ANS;
int lca;

void pre(){
	//memset(dp,inf,mxmx);
	for(int i=0;i<mxmx;i++)dp[i]=inf;
	//memset(par,-1,mxmx*lgn);
	for(int i=0;i<mxmx;i++){
		for(int j=0;j<lgn;j++){
			par[i][j]=-1;
		}
	}
}

void multi_bfs(){
	int ver,next,dist;
	for(int i=0;i<red.size();i++){
		ver=red[i].X;
		dist=red[i].Y;
		if(dp[ver]<=dist)continue;
		dp[ver]=dist;
		for(int j=0;j<adj[ver].size();j++){
			next=adj[ver][j];
			red.push_back(mp(next,dist+1));
		}
	}
}

void pre_dfs(int ver,int H){
	int next;
	h[ver]=H;
	for(int i=1;i<lgn;i++){
		if(par[ver][i-1]!=-1)par[ver][i]=par[par[ver][i-1]][i-1];
		else par[ver][i]=-1;
	}
	for(int i=0;i<adj[ver].size();i++){
		next=adj[ver][i];
		if(next!=par[ver][0]){
			par[next][0]=ver;
			pre_dfs(next,H+1);
		}
	}
}

int LCA(int a,int b){
	int A,B,ret;
	A=a;
	B=b;
	if(h[a]<h[b])swap(a,b);
	for(int i=lgn-1;i>=0;i--){
		if(h[par[a][i]]>=h[b]){
			a=par[a][i];
		}
	}
	if(a!=b){
		for(int i=lgn-1;i>=0;i--){
			if(par[a][i]!=par[b][i]){
				a=par[a][i];
				b=par[b][i];
			}
		}
		a=par[a][0];
		b=par[b][0];
	}
	ret=h[B]-h[a]+h[A]-h[a];
	if(ret<0)cout<<"YOU HAVE BUG HERE"<<endl;
	return ret;
}

int main(){
	ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
	pre();
	cin>>n>>m;
	for(int i=1,a,b;i<n;i++){
		cin>>a>>b;
		a--;
		b--;
		adj[a].push_back(b);
		adj[b].push_back(a);
	}
	pre_dfs(0,0);
	red.push_back(mp(0,0));
	for(int i=0,a,b;i<m;i++){
		cin>>a>>b;
		b--;
		if(a==1){
			red.push_back(mp(b,0));
			if(red.size()==V_){
				multi_bfs();
				red.clear();
			}
		}
		else{
			ANS=dp[b];
			for(int j=0;j<red.size();j++){
				lca=LCA(red[j].first,b);
				ANS=min(ANS,lca);
			}
			cout<<ANS<<endl;
		}
	}
}


#include<bits/stdc++.h>
using namespace std;
const int mxmx=1e5+10,inf=1e9+10,lg=20;
int n,m;
vector<int>adj[mxmx];
int vers[mxmx];
int h[mxmx],par[lg][mxmx];
void dfs(int ver){
    int next;
    if(par[0][ver]!=-1)h[ver]=h[par[0][ver]]+1;
    for(int i=1;i<lg;i++){
        if(par[i-1][ver]!=-1)par[i][ver]=par[i-1][par[i-1][ver]];
        else par[i][ver]=-1;
    }
    for(int i=0;i<adj[ver].size();i++){
        next=adj[ver][i];
        if(next!=par[0][ver]){
            par[0][next]=ver;
            dfs(next);
        }
    }
}
int LCA(int a,int b){
    if(h[a]<h[b])swap(a,b);
    for(int i=lg-1;i>=0;i--){
        if(par[i][a]!=-1){
            if(h[par[i][a]]>=h[b]){
                a=par[i][a];
            }
        }
    }
    for(int i=lg-1;i>=0;i--){
        if(par[i][a]!=-1){
            if(par[i][a]!=par[i][b]){
                a=par[i][a];
                b=par[i][b];
            }
        }
    }
    if(a!=b){
        a=par[0][a];
        b=par[0][b];
    }
    return a;
}
int I=0;
int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    scanf("%d %d",&n,&m);
    //cin>>n>>m;
    for(int i=1,u,v;i<n;i++){
        scanf("%d %d",&u,&v);
        //cin>>u>>v;
        u--;
        v--;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    par[0][0]=-1;
    dfs(0);
    vers[I]=0;
    I++;
    int lca,ANS;
    for(int i=0,a,b;i<m;i++){

        scanf("%d %d",&a,&b);
//        cin>>a>>b;
        b--;
        ANS=inf;
        if(a==2){
            for(int i=0;i<I;i++){
                lca=LCA(b,vers[i]);
                ANS=min(ANS,h[vers[i]]-2*h[lca]+h[b]);
            }
            printf("%d \n",ANS);
            //cout<<ANS<<endl;
        }
        else{
            vers[I]=b;
            I++;
        }
    }
}