//~ while (clock()<=69*CLOCKS_PER_SEC)
//~ #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
//~ #pragma GCC target ("avx2")
//~ #pragma GCC optimize("Ofast")
//~ #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
//~ #pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
using namespace std;

template <typename T>
using ordered_set =
    tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
    *this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define shandom_ruffle random_shuffle

using ll=long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
const int nax=300*1007;

int n, q;

int ojc[nax];
vi graf[nax];

int parz[nax];

int ile[2][2];
int stan;

int czyl[nax];

int ost[2][nax];

struct trzymacz
{
	int kt=0;
	int ichparz=0;
	vector<set<int>> poj;
	trzymacz()
	{
		poj.resize(2);
	}
	trzymacz(int a, int b)
	{
		poj.resize(2);
		kt=a;
		ichparz=b;
	}
	void dorzuc_nie(int v)
	{
		poj[0].insert(v);
	}
	void dorzuc_tak(int v)
	{
		ile[kt][ichparz]++;
		poj[1].insert(v);
	}
	void zamien_wszystko()
	{
		ile[kt][ichparz]-=(int)poj[1].size();
		poj[0].swap(poj[1]);
		ile[kt][ichparz]+=(int)poj[1].size();
	}
	int stan(int v)
	{
		return poj[1].count(v);
	}
	void flipnij(int v)
	{
		int x=stan(v);
		if (x)
			ile[kt][ichparz]--;
		else
			ile[kt][ichparz]++;
		poj[x].erase(v);
		poj[x^1].insert(v);
	}
	void wszystko_nie()
	{
		if ((int)poj[1].size()>(int)poj[0].size())
			zamien_wszystko();
		for (int i : poj[1])
			poj[0].insert(i);
		ile[kt][ichparz]-=(int)poj[1].size();
		poj[1].clear();
	}
	void wszystko_tak()
	{
		wszystko_nie();
		zamien_wszystko();
	}
	int cokolwiek()
	{
		return !poj[1].empty();
	}
};

trzymacz trzymacze[2][nax];

struct pojemnik
{
	int num;
	//~ vector<vector<pii>> wek;
	set<pii> setel;
	pojemnik()
	{
		
	}
	pojemnik(int nn)
	{
		num=nn;
		//~ wek.resize(2);
	}
	void insert(pii v)
	{
		setel.insert(v);
	}
	void erase(pii v)
	{
		setel.erase(v);
	}
	int empty()
	{
		return setel.empty();
	}
	vi lista()
	{
		vi ret;
		for (pii i : setel)
			ret.push_back(i.second);
		return ret;
	}
	pii daj()
	{
		return *setel.begin();
	}
	//~ void insert(pii v)
	//~ {
		//~ ost[num][v.second]++;
		//~ wek[v.first].push_back({ost[num][v.second], v.second});
	//~ }
	//~ int empty()
	//~ {
		//~ for (int i=0; i<2; i++)
			//~ while(!wek[i].empty() && wek[i].back().first!=ost[num][wek[i].back().second])
				//~ wek[i].pop_back();
		//~ return wek[0].empty() && wek[1].empty();
	//~ }
	//~ pii daj()
	//~ {
		//~ empty();
		//~ for (int i=0; i<2; i++)
			//~ if (!wek[i].empty())
				//~ return {i, wek[i].back().second};
		//~ assert(0);
	//~ }
	//~ int empty1()
	//~ {
		//~ empty();
		//~ return wek[1].empty();
	//~ }
	//~ pii daj1()
	//~ {
		//~ empty();
		//~ if (!wek[1].empty())
			//~ return {1, wek[1].back().second};
		//~ assert(0);
	//~ }
	//~ vi lista()
	//~ {
		//~ vi ret;
		//~ for (int i=0; i<2; i++)
		//~ {
			//~ while(!wek[i].empty())
			//~ {
				//~ if (wek[i].back().first==ost[num][wek[i].back().second])
					//~ ret.push_back(wek[i].back().second);
				//~ wek[i].pop_back();
			//~ }
		//~ }
		//~ return ret;
	//~ }
};

//~ set<pii> zazdz[2][nax];
//~ set<pii> niedz[2][nax];

pojemnik zazdz[2][nax];
pojemnik niedz[2][nax];

int zazn[2][nax];

vi swieze[2];

void dfs1(int v)
{
	for (int &i : graf[v])
	{
		if (i==ojc[v])
		{
			swap(i, graf[v].back());
			graf[v].pop_back();
			break;
		}
	}
	for (int i : graf[v])
	{
		ojc[i]=v;
		parz[i]=parz[v]^1;
		dfs1(i);
	}
}

int wynik()
{
	return ile[0][stan]+ile[1][stan^1];
}

void flip(int kt, int v)
{
	//~ debug() << "flipuje " << imie(kt) << imie(v);
	if (zazn[kt][v])
	{
		//~ trzymacze[kt][v].wszystko_nie();
		ile[kt][parz[v]]--;
		zazn[kt][v]=0;
		if (v>1)
		{
			//~ iledz[kt][ojc[v]]--;
			zazdz[kt][ojc[v]].erase({!czyl[v], v});
			niedz[kt][ojc[v]].insert({!czyl[v], v});
		}
	}
	else
	{
		//~ trzymacze[kt][v].wszystko_tak();
		ile[kt][parz[v]]++;
		zazn[kt][v]=1;
		if (v>1)
		{
			//~ iledz[kt][ojc[v]]++;
			zazdz[kt][ojc[v]].insert({!czyl[v], v});
			niedz[kt][ojc[v]].erase({!czyl[v], v});
		}
	}
}

int isfake(int kt, int v)
{
	return zazn[kt][v] && parz[v]!=(stan^kt) && !zazn[kt][ojc[v]] && zazdz[kt][v].empty() && !trzymacze[kt][v].cokolwiek();
}

vi dod, pom;

int ostczy[nax];
int czasczy;

void przeczysc(vi &wek)
{
	czasczy++;
	vi pom;
	for (int i : wek)
	{
		if (ostczy[i]!=czasczy)
		{
			ostczy[i]=czasczy;
			pom.push_back(i);
		}
	}
	
	pom.swap(wek);
}

void rozszerz(int kt)//najpierw usun spojne rozmiaru jeden zlej parzystosci
{
	dod.clear();
	pom.clear();
	pom.swap(swieze[kt]);
	
	przeczysc(pom);
	
	for (int i : pom)
	{
		if (parz[i]!=(stan^kt))
		{
			if (isfake(kt, i))
				flip(kt, i);
			if (zazn[kt][i])
				swieze[kt].push_back(i);
		}
		else
		{
			if (!zazn[kt][i])
			{
				if (i>1 && isfake(kt, ojc[i]))
					flip(kt, ojc[i]);
				if (i>1 && !isfake(kt, ojc[i]) && zazn[kt][ojc[i]])
					swieze[kt].push_back(i);
				while(1)
				{
					if (zazdz[kt][i].empty())
						break;
					int d=zazdz[kt][i].daj().second;
					if (!isfake(kt, d))
					{
						swieze[kt].push_back(i);
						break;
					}
					flip(kt, d);
				}
				
				trzymacze[kt][i].wszystko_nie();
			}
		}
	}
	
	for (int i : pom)
	{
		//~ debug() << imie(i) << imie(zazn[kt][i]) << imie(parz[i]==(stan^kt));
		if (!zazn[kt][i] && parz[i]!=(kt^stan))//zaraza sie
		{
			if ((i>1 && zazn[kt][ojc[i]]) || !zazdz[kt][i].empty() || trzymacze[kt][i].cokolwiek())
				dod.push_back(i);
			continue;
		}
		if (zazn[kt][i] && parz[i]==(kt^stan))//zaraza somsiadow
		{
			if (i>1 && !zazn[kt][ojc[i]])
				dod.push_back(ojc[i]);
			for (int j : niedz[kt][i].lista())
				dod.push_back(j);
			trzymacze[kt][i].wszystko_tak();
			continue;
		}
		//~ swieze[kt].push_back(i);
	}
	
	for (int i : dod)
	{
		if (!zazn[kt][i])
		{
			flip(kt, i);
			swieze[kt].push_back(i);
			trzymacze[kt][i].wszystko_tak();
		}
	}
	
}

int main()
{
	scanf("%d%d", &n, &q);
	for (int i=1; i<n; i++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		graf[a].push_back(b);
		graf[b].push_back(a);
	}
	for (int i=2; i<=n; i++)
		czyl[i]=(((int)graf[i].size())==1);
	
	dfs1(1);
	
	for (int h=0; h<2; h++)
	{
		for (int i=1; i<=n; i++)
		{
			niedz[h][i]=pojemnik(h);
			zazdz[h][i]=pojemnik(h);
		}
		for (int i=1; i<=n; i++)
		{
			trzymacze[h][i]=trzymacz(h, parz[i]^1);
		}
	}
	
	for (int h=0; h<2; h++)
	{
		for (int i=2; i<=n; i++)
		{
			if (!czyl[i])
				niedz[h][ojc[i]].insert({!czyl[i], i});
		}
		for (int i=2; i<=n; i++)
		{
			if (czyl[i])
			{
				if (0 && niedz[h][ojc[i]].empty())
				{
					czyl[i]=0;
					niedz[h][ojc[i]].insert({!czyl[i], i});
				}
				else
				{
					trzymacze[h][ojc[i]].dorzuc_nie(i);
				}
			}
		}
	}
	while(q--)
	{
		int typ;
		scanf("%d", &typ);
		if (typ<=1)
		{
			int v;
			scanf("%d", &v);
			
			for (int i=0; i<2; i++)
			{
				if (parz[v]!=(stan^i))
					continue;
				
				if (czyl[v])
				{
					if (trzymacze[i][ojc[v]].stan(v)!=typ)
					{
						trzymacze[i][ojc[v]].flipnij(v);
						swieze[i].push_back(ojc[v]);
					}
				}
				else
				{
					if (zazn[i][v]!=typ)
					{
						flip(i, v);
						swieze[i].push_back(v);
					}
				}
			}
		}
		if (typ==2)
		{
			rozszerz(0);
			rozszerz(1);
			stan^=1;
		}
		printf("%d ", wynik());
		//~ debug();
		//~ debug() << range(zazn[0]+1, zazn[0]+1+n);
		//~ debug() << range(zazn[1]+1, zazn[1]+1+n);
		//~ debug() << imie(swieze[0]) << imie(swieze[1]);
		//~ debug();
	}
	printf("\n");
	return 0;
}