#include <iostream>
#include <cstdio>
#include <math.h>
#include <algorithm>
#include <vector>
#include <string.h>
#include <set>
#include <map>
#include <bitset>
#include <time.h>
using namespace std;

typedef vector <int> vi;

#define ll long long
#define pb push_back
#define ld double
#define pld pair <ld, ld>
#define pll pair <ll, ll>
#define fi first
#define pii pair <int, int>
#define se second
#define mp make_pair

const int MAXN = 100 * 1000;
const int INF = 1000 * 1000;

int cnt[MAXN], pr[MAXN], ind[MAXN], num[MAXN];
int cntt = 0;
vector <int> g[MAXN];
bool is_heavy(int v, int pr)
{
	return (cnt[v] < cnt[pr]) && (cnt[v] * 2 >= cnt[pr]);
}

class tree
{
public:
	int len;
	int ne;
	vector <int> t;
	vector <int> node;
	void build(int v)
		{
			while (is_heavy(v, pr[v]))
			{
				ind[v] = (int)node.size();
				node.pb(v);
				num[v] = cntt;
				v = pr[v];
			}
			
			if (v)
			{
				ind[v] = (int)node.size();
				node.pb(v);
				num[v] = cntt;
				ne = pr[v];
			}
			for (len = 1; len < (int)node.size(); len *= 2);
			t.assign(2 * len, INF);
		}
	
    
	void update(int ind, int v, int l, int r)
		{
			if (l == r)
			{
				if (t[v] == INF)
					t[v] = node[v - len];
				else
					t[v] = INF;
				return;
			}
			int s = (l + r) / 2;
			if (ind <= s)
				update(ind, 2 * v, l, s);
			else
				update(ind, 2 * v + 1, s + 1, r);
			if (t[2 * v] == INF)
				t[v] = t[2 * v + 1];
			else
				t[v] = t[2 * v];
		}
	int find(int tl, int tr, int v, int l, int r)
		{
			if (tl > tr) return INF;
			if (tl == l && tr == r)
				return t[v];
			int s = (l + r) /s;
			int vall = find(tl, min(s, tr), 2 * v, l, s);
			int valr = find(max(tl, s + 1), tr, 2 * v + 1, s + 1, r);
			if (vall == INF) return valr;
			return vall;
		}
};

tree t[MAXN];
int dfs(int v, int _pr)
{
	pr[v] = _pr;
	cnt[v] = 1;
	for (int i = 0; i < (int)g[v].size(); i++)
		if (g[v][i] != _pr)
			cnt[v] += dfs(g[v][i], v);
	return cnt[v];
}


void find_path(int v)
{
	bool ok = 1;
	for (int i = 0; i < (int)g[v].size(); i++)
		if (g[v][i] != pr[v])
		{
			if (is_heavy(g[v][i], v))
				ok = 0;
			find_path(g[v][i]);
		}
	if (ok)
		t[cntt].build(v), cntt++;
}
	

int color[MAXN];
int _type[MAXN * 4],  _v[MAXN * 4];
int main()
{
	//freopen("subsequences.in", "r", stdin);
	//freopen("subsequences.out", "w", stdout);
//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);
	ios_base::sync_with_stdio(false);
	int n, q;
	cin >> n >> q;
	for (int i = 0; i < n - 1; i++)
	{
		int a, b;
		cin >> a >> b;
		a--, b--;
		g[a].pb(b);
		g[b].pb(a);
	}
	for (int i = 0; i < q; i++)
		cin >> _type[i] >> _v[i];
	dfs(0, 0);
	find_path(0);
	//for (int i = 0; i < cntt; i++)
//	{
//		for (int j = 0; j < (int)t[i].node.size(); j++)
//			cout << t[i].node[j] << " ";
//		cout << endl;
//	}
//	for (int i = 0; i < n; i++)
//		cout << ind[i] << endl;
	//return 0;
	for (int i = 0; i < q; i++)
	{
		int type = _type[i];
		int v = _v[i];
		v--;
		if (type)
		{
			int len = t[num[v]].len;
			int ans = INF;
			while (v && ans == INF)
			{
				ans = t[num[v]].find(ind[v] + len, len * 2 - 1, 1, len, len * 2 - 1);
				v = t[num[v]].ne;
			}
		    if (ans == INF && color[0]) ans = 0;
			if (ans == INF)
				cout << -1;
			else
				cout << ans + 1;
			cout << '\n';
		}
		else
		{
			color[v] = 1 - color[v];
			if (v)
			{
				int len = t[num[v]].len;
				t[num[v]].update(ind[v] + len, 1, len, len * 2 - 1);
			}
				
		}
	}
	return 0;
}