//~ 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=1000*1007;

int n, q;

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

int parz[nax];

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

int czyl[nax];

set<pii> zazdz[2][nax];
set<pii> 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])
	{
		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
	{
		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]]+(int)zazdz[kt][v].size());
}

void rozszerz(int kt)//najpierw usun spojne rozmiaru jeden zlej parzystosci
{
	vi dod;
	vi pom=swieze[kt];
	swieze[kt].clear();
	
	sort(pom.begin(), pom.end());
	pom.resize(unique(pom.begin(), pom.end())-pom.begin());
	
	for (int i : pom)
	{
		if (parz[i]!=(stan^kt))
		{
			if (isfake(kt, i))
				flip(kt, i);
			//~ else
				//~ 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].begin()).second;
					if (!isfake(kt, d))
					{
						swieze[kt].push_back(i);
						break;
					}
					flip(kt, d);
				}
				
				//~ swieze[kt].push_back(i);
			}
		}
	}
	
	//~ debug() << imie(kt) << imie(pom);
	
	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
		{
			int jest=0;
			if (i>1 && zazn[kt][ojc[i]])
			{
				if (isfake(kt, ojc[i]))
					flip(kt, ojc[i]);
				else
					jest=1;
			}
			while(!jest && !zazdz[kt][i].empty())
			{
				int d=(*zazdz[kt][i].begin()).second;
				if (isfake(kt, d))
					flip(kt, d);
				else
					jest=1;
			}
			
			if (!jest)
				continue;
			
			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 (pii j : niedz[kt][i])
				dod.push_back(j.second);
			continue;
		}
		//~ if (zazn[kt][i])
			//~ swieze[kt].push_back(i);
	}
	
	sort(dod.begin(), dod.end());
	dod.resize(unique(dod.begin(), dod.end())-dod.begin());
	
	for (int i : dod)
	{
		if (!zazn[kt][i])
		{
			flip(kt, i);
			swieze[kt].push_back(i);
		}
	}
	
}

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=1; i<=n; i++)
		czyl[i]=(((int)graf[i].size())==1);
	dfs1(1);
	for (int h=0; h<2; h++)
		for (int i=2; i<=n; i++)
			niedz[h][ojc[i]].insert({!czyl[i], 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 (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;
}