#include <bits/stdc++.h>

namespace std {

template<class Fun>
class y_combinator_result {
	Fun fun_;
public:
	template<class T>
	explicit y_combinator_result(T &&fun): fun_(std::forward<T>(fun)) {}

	template<class ...Args>
	decltype(auto) operator()(Args &&...args) {
		return fun_(std::ref(*this), std::forward<Args>(args)...);
	}
};

template<class Fun>
decltype(auto) y_combinator(Fun &&fun) {
	return y_combinator_result<std::decay_t<Fun>>(std::forward<Fun>(fun));
}

} // namespace std

template <typename T, class Compare = std::less<T>> class RangeMinQuery : private Compare {
	static const int BUCKET_SIZE = 32;
	static const int BUCKET_SIZE_LOG = 5;
	static_assert(BUCKET_SIZE == (1 << BUCKET_SIZE_LOG), "BUCKET_SIZE should be a power of 2");
	static const int CACHE_LINE_ALIGNMENT = 64;
	int n = 0;
	std::vector<T> data;
	std::vector<T> pref_data;
	std::vector<T> suff_data;
	std::vector<T> sparse_table;
	std::vector<uint32_t> range_mask;

private:
	int num_buckets() const {
		return n >> BUCKET_SIZE_LOG;
	}
	int num_levels() const {
		return num_buckets() ? 32 - __builtin_clz(num_buckets()) : 0;
	}
	int sparse_table_size() const {
		return num_buckets() * num_levels();
	}
private:
	const T& min(const T& a, const T& b) const {
		return Compare::operator()(a, b) ? a : b;
	}
	void setmin(T& a, const T& b) const {
		if (Compare::operator()(b, a)) a = b;
	}

	template <typename Vec> static int get_size(const Vec& v) { using std::size; return int(size(v)); }

public:
	RangeMinQuery() {}
	template <typename Vec> explicit RangeMinQuery(const Vec& data_, const Compare& comp_ = Compare())
		: Compare(comp_)
		, n(get_size(data_))
		, data(n)
		, pref_data(n)
		, suff_data(n)
		, sparse_table(sparse_table_size())
		, range_mask(n)
	{
		for (int i = 0; i < n; i++) data[i] = data_[i];
		for (int i = 0; i < n; i++) {
			if (i & (BUCKET_SIZE-1)) {
				uint32_t m = range_mask[i-1];
				while (m && !Compare::operator()(data[(i | (BUCKET_SIZE-1)) - __builtin_clz(m)], data[i])) {
					m -= uint32_t(1) << (BUCKET_SIZE - 1 - __builtin_clz(m));
				}
				m |= uint32_t(1) << (i & (BUCKET_SIZE - 1));
				range_mask[i] = m;
			} else {
				range_mask[i] = 1;
			}
		}
		for (int i = 0; i < n; i++) {
			pref_data[i] = data[i];
			if (i & (BUCKET_SIZE-1)) {
				setmin(pref_data[i], pref_data[i-1]);
			}
		}
		for (int i = n-1; i >= 0; i--) {
			suff_data[i] = data[i];
			if (i+1 < n && ((i+1) & (BUCKET_SIZE-1))) {
				setmin(suff_data[i], suff_data[i+1]);
			}
		}
		for (int i = 0; i < num_buckets(); i++) {
			sparse_table[i] = data[i * BUCKET_SIZE];
			for (int v = 1; v < BUCKET_SIZE; v++) {
				setmin(sparse_table[i], data[i * BUCKET_SIZE + v]);
			}
		}
		for (int l = 0; l+1 < num_levels(); l++) {
			for (int i = 0; i + (1 << (l+1)) <= num_buckets(); i++) {
				sparse_table[(l+1) * num_buckets() + i] = min(sparse_table[l * num_buckets() + i], sparse_table[l * num_buckets() + i + (1 << l)]);
			}
		}
	}

	T query(int l, int r) const {
		assert(l <= r);
		int bucket_l = (l >> BUCKET_SIZE_LOG);
		int bucket_r = (r >> BUCKET_SIZE_LOG);
		if (bucket_l == bucket_r) {
			uint32_t msk = range_mask[r] & ~((uint32_t(1) << (l & (BUCKET_SIZE-1))) - 1);
			int ind = (l & ~(BUCKET_SIZE-1)) + __builtin_ctz(msk);
			return data[ind];
		} else {
			T ans = min(suff_data[l], pref_data[r]);
			bucket_l++;
			if (bucket_l < bucket_r) {
				int level = (32 - __builtin_clz(bucket_r - bucket_l)) - 1;
				setmin(ans, sparse_table[level * num_buckets() + bucket_l]);
				setmin(ans, sparse_table[level * num_buckets() + bucket_r - (1 << level)]);
			}
			return ans;
		}
	}
};
namespace zyk
{
	using namespace std;
	#define fi first
	#define se second
	using path_t = pair<int, int>;
	using diam_t = pair<int, path_t>;
	constexpr int N = 2e5 + 10, inf = 1e9;
	int n, q, ans[N];
	int son[N], sz[N], top[N], fa[N], dep[N], len[N];
	int st[N][20];
	vector<int> G[N];
	namespace sub1 {
		vector<pair<int, int>> qry[N];
		int rt, all, mx[N], sz[N], vis[N];
		int dep[N], cnt[N];
		void findrt(int u, int par) {
			sz[u] = 1, mx[u] = 0;
			for(auto v : G[u]) if(v != par && !vis[v]) {
				findrt(v, u);
				sz[u] += sz[v];
				mx[u] = max(mx[u], sz[v]);
			}
			mx[u] = max(mx[u], all - sz[u]);
			if(mx[u] < mx[rt]) rt = u;
		}
		void calc(int u, int par, int k) {
			vector<int> s;
			int mx = 0;
			function<void(int, int)> dfs = [&](int u, int par) {
				cnt[dep[u]] ++;
				mx = max(mx, dep[u]);
				s.emplace_back(u);
				for(auto v : G[u]) if(v != par && !vis[v]) {
					dep[v] = dep[u] + 1;
					dfs(v, u);
				}
			};
			dfs(u, par);
			for(int i = 0; i <= mx; i ++) cnt[i] += cnt[i - 1];
			for(auto u : s) for(auto [d, id] : qry[u]) {
				if(d >= dep[u])	ans[id] += k * cnt[min(mx, d - dep[u])];
			}
			for(int i = 0; i <= mx; i ++) cnt[i] = 0;
		}
		void solve(int u) {
			vis[u] = 1;
			dep[u] = 0;
			calc(u, u, 1);
			for(auto v : G[u]) if(!vis[v]) {
				calc(v, u, -1);
			}
			for(auto v : G[u]) if(!vis[v]) {
				findrt(v, u), rt = 0, all = sz[v], findrt(v, u), solve(rt);
			}
		}
		void work() {
			for (int i=0;i<=n;i++) vis[i]=0,dep[i]=0,mx[i]=sz[i]=vis[i]=cnt[i]=0;
			mx[rt = 0] = inf, all = n, findrt(1, 1);
			solve(rt);
		}
	}
	namespace sub2 {
		vector<pair<int, int>> qry[N];
		int *f[N], mem[N << 1], *cur = mem;
		int totc=0;
		void append(int u) {
			f[u] = cur, cur += len[u] + 1;
			totc+=len[u]+1;
		}
		struct Bit {
			int vis[N], c[N], timer;
			void upd(int p, int x) {
				for(; p; p -= p & -p) {
					if(vis[p] != timer) c[p] = 0, vis[p] = timer;
					c[p] += x;
				}
			}
			int qry(int p) {
				int ans = 0;
				for(; p < N; p += p & -p) {
					if(vis[p] != timer) c[p] = 0, vis[p] = timer;
					ans += c[p];
				}
				return ans;
			}
			void clear() {
				timer ++;
			}
		}ds;
		void dfs(int u) {
			f[u][0] = 1;
			if(son[u]) f[son[u]] = f[u] + 1, dfs(son[u]);
			for(auto v : G[u]) if(v != fa[u] && v != son[u]) {
				append(v);
				dfs(v);
				for(int i = 0; i <= len[v]; i ++) f[u][i + 1] += f[v][i];
			}
			if(top[u] == u) {
				vector<vector<pair<int, int>>> upd(len[u] + 1);
				vector<vector<pair<int, int>>> ask(len[u] + 1);
				int cnt = 0;
				for(int x = u; x; x = son[x]) {
					cnt ++;
					for(auto [d, id] : qry[x]) {
						if(d <= len[x]) ask[d].emplace_back(cnt + d, id);
					}
					upd[0].emplace_back(1, cnt);
					for(auto y : G[x]) if(y != son[x] && y != fa[x]) {
						for(int i = 0; i <= len[y]; i ++) {
							upd[i + 1].emplace_back(f[y][i], cnt + i + 1);
						}
					}
				}
				ds.clear();
				for(int i = 0; i <= len[u]; i ++) {
					for(auto [w, p] : upd[i]) {
						ds.upd(p, w);
					}
					for(auto [p, id] : ask[i]) {
						if(id > 0) ans[id] += ds.qry(p);
						else ans[-id] -= ds.qry(p);
					}
	 			}
			}
		}
		void add(int u, int v, int d, int id) {
			while(top[u] != top[v]) {
				qry[son[u]].emplace_back(d, -id);
				qry[top[u]].emplace_back(d, id);
				u = fa[top[u]];
			}
			qry[son[u]].emplace_back(d, -id);
			qry[son[v]].emplace_back(d, id);
		}
		void work() {
			cur=mem;
			for (int i=0;i<totc;i++) mem[i]=0;
			totc=0;
			append(1);
			dfs(1);
		}
	}
	void dfs1(int u, int par) {
		st[u][0]=par;
		for (int i=1;i<20;i++)
			st[u][i]=st[st[u][i-1]][i-1];
		sz[u] = 1, fa[u] = par, dep[u] = dep[par] + 1,son[u]=0,len[u]=0;
		for(auto v : G[u]) if(v != par) {
			dfs1(v, u);
			sz[u] += sz[v];
			if(sz[v] > sz[son[u]]) son[u] = v;
			len[u] = max(len[u], len[v] + 1);
		}
	}
	void dfs2(int u, int tpar) {
		top[u] = tpar;
		if(son[u]) dfs2(son[u], tpar);
		for(auto v : G[u]) if(v != fa[u] && v != son[u]) {
			dfs2(v, v);
		}
	}
	void init() {
		dfs1(1, 1), dfs2(1, 1);	
		for (int i=0;i<=n;i++) vector<pair<int,int>>().swap(sub1::qry[i]);
		for (int i=0;i<=n;i++) vector<pair<int,int>>().swap(sub2::qry[i]);
		sub2::cur=sub2::mem;
	}
	int lca(int u, int v)
	{
		while(top[u] != top[v])
		{
			if(dep[top[u]] < dep[top[v]]) swap(u, v);
			u = fa[top[u]];
		}
		return dep[u] < dep[v] ? u : v;
	}
	int dis(int x,int y)
	{
		return dep[x]+dep[y]-2*dep[lca(x,y)];
	}
	inline int jmp(int x,int y)
	{
		for (int i=19;i>=0;i--)
			if((y>>i)&1) x=st[x][i];
		return x;
	}
	void wtf(int nn,int qq,vector<vector<int>>adj,vector<diam_t>ds,vector<int>qrys) {
		n=nn;
		q=qq;
		for(int i = 1; i <= n; i ++) 
		{
			G[i]=adj[i-1];
			for (auto &u:G[i]) u++;
		}
		init();
		for(int i = 1; i <= q; i ++) ans[i]=0;
		for(int i = 1; i <= q; i ++)
		{
			if (qrys[i-1]==-1) continue;
			int u, v, d;
			u=ds[i-1].se.fi,v=ds[i-1].se.se;
			d=ds[i-1].fi;
			if (u==-1)
			{
				qrys[i-1]=-2;
				continue;
			}
			u++,v++;
			// cout<<u<<" "<<v<<" "<<d<<endl;
			if (d!=0)
			{
				if (dep[u]<dep[v]) swap(u,v);
				if (d%2==0)
				{
					u=v=jmp(u,d/2);
				} else 
				{
					u=jmp(u,d/2);
					v=st[u][0];
				}
				d=qrys[i-1]-(d+1)/2;
			} else d=qrys[i-1];
			if (u==-1||d<0)
			{
				qrys[i-1]=-2;
				continue;
			}
			int w = lca(u, v);
			sub1::qry[w].emplace_back(d, i);
			sub2::add(u, w, d, i);
			sub2::add(v, w, d, i);
		}
		sub1::work();
		sub2::work();
		for(int i = 1; i <= q; i ++) {
			if (qrys[i-1]==-1) continue;
			if (qrys[i-1]==-2) cout<<0<<'\n';
			else
				cout << ans[i] << '\n';
		}
	}
}
void BellaKira()
{
using namespace std;
	using path_t = pair<int, int>;
	using diam_t = pair<int, path_t>;

	int N, Q; cin >> N >> Q;
	vector<vector<int>> adj(N);
	for (int e = 0; e < N-1; e++) {
		int u, v; cin >> u >> v; u--, v--;
		adj[u].push_back(v);
		adj[v].push_back(u);
	}

	vector<int> depth(N);
	vector<int> preorder_idx(N);
	vector<pair<int, int>> preorder_lcas(N-1);
	int cur_idx = 0;
	std::y_combinator([&](auto self, int cur, int prv = -1) -> void {
		depth[cur] = (prv == -1 ? 0 : depth[prv] + 1);
		preorder_idx[cur] = cur_idx;
		cur_idx++;
		for (int nxt : adj[cur]) {
			if (nxt == prv) continue;
			preorder_lcas[cur_idx-1] = max(preorder_lcas[cur_idx-1], {depth[cur], cur});
			self(nxt, cur);
		}
	})(0);

	RangeMinQuery<pair<int, int>> lca_rmq(preorder_lcas);

	auto lca = [&](int a, int b) {
		if (a == b) return a;
		a = preorder_idx[a];
		b = preorder_idx[b];
		if (a > b) swap(a, b);
		return lca_rmq.query(a, b-1).second;
	};

	auto dist = [&](int a, int b) {
		return depth[a] + depth[b] - 2 * depth[lca(a,b)];
	};


	auto closest_pt = [&](int a, path_t p) {
		int c = lca(p.first, p.second);
		int x = lca(a, p.first);
		int y = lca(a, p.second);
		return max({c,x,y}, [&](int u, int v) { return depth[u] < depth[v]; });
	};

	diam_t NO_DIAM{int(1e9), path_t{-1, -1}};

	auto build_diam = [&](int a, int b) -> diam_t {
		return {dist(a,b), {a,b}};
	};

	auto update_diam = [&](diam_t d, path_t a) -> diam_t {
		if (d == NO_DIAM) return {0, a};
		int x = closest_pt(d.second.first, a);
		int y = closest_pt(d.second.second, a);
		if (x != y) {
			if (d.first == 0) {
				return {0, {x, y}};
			} else {
				return d;
			}
		}
		assert(x == y);
		if (d.first == 0) {
			int z = closest_pt(x, d.second);
			return build_diam(x, z);
		} else {
			return max({d, build_diam(d.second.first, x), build_diam(d.second.second, x)});
		}
	};

	set<pair<path_t, int>> alive;
	vector<vector<path_t>> ops(2*Q);
	vector<int> queries(Q, -1);

	for (int q = 0; q < Q; q++) {
		int op; cin >> op;
		if (op == 1 || op == 2) {
			int u, v; cin >> u >> v; u--, v--;
			if (u > v) swap(u, v);
			path_t path(u, v);
			if (op == 1) {
				alive.insert({path, q});
			} else {
				auto it = alive.lower_bound({path, -1});
				assert(it != alive.end() && it->first == path);
				int t0 = it->second;
				alive.erase(it);

				for (int a = Q+t0, b = Q+q; a < b; a >>= 1, b >>= 1) {
					if (a & 1) ops[a++].push_back(path);
					if (b & 1) ops[--b].push_back(path);
				}
			}
		} else if (op == 3) {
			int d; cin >> d;
			queries[q] = d;
		} else assert(false);
	}
	for (auto it : alive) {
		int t0 = it.second;
		path_t path = it.first;
		for (int a = Q+t0, b = Q+Q; a < b; a >>= 1, b >>= 1) {
			if (a & 1) ops[a++].push_back(path);
			if (b & 1) ops[--b].push_back(path);
		}
	}

	vector<diam_t> actual_diam(Q);
	std::y_combinator([&](auto self, int a, diam_t d) -> void {
		for (path_t p : ops[a]) {
			d = update_diam(d, p);
		}
		if (a >= Q) {
			actual_diam[a-Q] = d;
		} else {
			self(2*a, d);
			self(2*a+1, d);
		}
	})(1, NO_DIAM);
	// cout<<"??"<<endl;
	zyk::wtf(N,Q,adj,actual_diam,queries);
	return;
}
signed main()
{
	using namespace std;
	int T=1;
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cin>>T;
	while (T--)
	{
		BellaKira();
	}
}