#include <cstdio>
#include <algorithm>
#include <vector>
#include <cstring>
#include <numeric>
#include <cassert>
#include <cmath>
#include <map>
#include <unordered_map>
#include <set>
#include <random>
#include <vector>
#include <iostream>
#include <string>
#include <complex>
#include <functional>
#pragma warning(disable:4146)

#define FOR(k,a,b) for(int k(a); k < (b); ++k)
#define REP(k,a) for(int k=0; k < (a); ++k)
#define ABS(a) ((a)>0?(a):-(a))

using namespace std;

typedef long long LL;
typedef unsigned int uint;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<double> VD;
typedef vector<PII> VPII;
typedef vector<VPII> VVPII;
typedef vector<VI> VVI;
typedef vector<VD> VVD;
typedef vector<bool > VB;
typedef vector<VB> VVB;

VI part, mi1, mi2, si;

int get(int pos)
{
	if (pos < 0) return -1;
	int origpos = pos, next;
	while(pos != part[pos])
	{
		pos = part[pos];
	}
	while (origpos != pos)
	{
		next = part[origpos];
		part[origpos] = pos;
		origpos = next;
	}
	return pos;
}

void updatemins(int ap)
{
	int start = mi2[ap] - 1;
	int mi1p = get(mi1[ap]);
	int mi2p = get(mi2[ap]);
	int need = 0;
	if (mi1p == ap && mi2p == ap)
	{
		need = 2;
	}
	else if (mi1p == ap || mi2p == ap)
	{
		if (mi1p == ap)
		{
			mi1[ap] = mi2[ap];
		}
		need = 1;
	}
	while (need && start >= 0)
	{
		int candp = get(start);
		if (candp != ap)
		{
			if (need == 2)
			{
				mi1[ap] = start;
			}
			else
			{
				mi2[ap] = start;
			}
			--need;
		}
		--start;
	}
	if (need)
		mi2[ap] = -1;
	if (need == 2)
		mi1[ap] = -1;
}

void merge(int a, int b)
{
	if(a == b)
		return;
	int ap = get(a);
	int as = si[ap];
	int bp = get(b);
	int bs = si[bp];
	if(as < bs)
	{
		swap(as, bs);
		swap(ap,bp);
	}
	part[bp] = ap;
	si[ap] += si[bp];
	//update mi1,mi2
	updatemins(ap);
}

int main(int argc, char** argv) {
#ifdef HOME
	freopen("in.txt", "rb", stdin);
	freopen("out.txt", "wb", stdout);
#endif
	int T,n,m,u,v;
	scanf("%d", &T);
	assert(1<= T && T <= 10);
	int qq = 0;
	REP(tc,T)
	{
		scanf("%d %d", &n,&m);
		assert(1 <= n && n <= 100000);
		assert(1 <= m && m <= 100000);
		part.clear();
		si.clear();
		mi1.clear();
		mi2.clear();
		part.resize(n);
		mi1.resize(n, n -1);
		mi2.resize(n, n -2);
		si.resize(n, 1);
		REP(i, n)
			part[i] = i;
		VPII Q;
		VB br(n);
		VVI edges(n);
		REP(i,n-1)
		{
			scanf("%d %d", &u, &v);
			assert(1 <= u && u <= n);
			assert(1 <= v && v <= n);
			--u, --v;
			edges[u].push_back(v);
			edges[v].push_back(u);
		}
		REP(i,m)
		{
			scanf("%d %d", &u, &v);
			assert(u == 1 || u == 2);
			assert(1 <= v && v <= n);
			--v;
			if(u==1)
			{
				if(!br[v])
				{
					br[v] = 1;
					Q.push_back(make_pair(1, v));
				}
			}
			else
			{
				Q.push_back(make_pair(2, v));
			}

		}
		reverse(Q.begin(), Q.end());
		REP(i,n) if(!br[i])
		{
			int ip = get(i);
			REP(j,edges[i].size()) if (!br[edges[i][j]])
			{
				int o = edges[i][j];
				int op = get(o);
				merge(ip, op);
			}
		}
		VI ans;
		REP(q,Q.size())
		{
			v = Q[q].second;
			if(Q[q].first == 1)
			{
				br[v] = 0;
				int vp = v;
				REP(j, edges[v].size()) if (!br[edges[v][j]])
				{
					int o = edges[v][j];
					int op = get(o);
					merge(vp, op);
				}
			}
			else
			{
				qq++;
				int vp = get(v);
				if(si[vp] > 1 || !br[vp])
					updatemins(vp);
				ans.push_back(mi2[vp]);
			}
		}
		reverse(ans.begin(), ans.end());
		REP(i,ans.size())
		{
			printf("%d\n", ans[i] > -1 ? ans[i] + 1 : ans[i] );
		}
	}
	return 0;
}