#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i< (n); ++i)
#define repi(i, a, b) for (int i = (a); i < (b); ++i)
#define all(x) (x).begin(), (x).end()
#define fore(i, a) for(auto &i:a)
using ll = long long;
#include<atcoder/segtree>
using namespace atcoder;
void chmin(int &a, int b){if(b < a) a = b;}
class HLdecomposition{
	private:
		int V;
		vector<vector<int> > G, paths;
		vector<int> stsize, parent, pathtop, in, out, ind_in_path, which_path, dist;
		int root, c, d;
		void BuildStsize(int u, int p){
			stsize[u] = 1, parent[u] = p;
			for(int& v : G[u]){
				if(v == p){
					if(v == G[u].back()) break;
					else swap(v, G[u].back());
				}
				BuildStsize(v, u);
				stsize[u] += stsize[v];
				if(stsize[v] > stsize[G[u][0]]){
					swap(v, G[u][0]);
				}
			}
		}
		void BuildPath(int u, int p, int& tm){
			which_path[u] = c;
			ind_in_path[u] = d++;
			paths[c].push_back(u);
			in[u] = tm++;
			for(int v : G[u]){
				if(v == p) continue;
				dist[v] = dist[u]+1;
				if(v == G[u][0]){
					pathtop[v] = pathtop[u];
				}
				else{
					pathtop[v] = v;
					c++;
					paths.emplace_back();
					d = 0;
        }
				BuildPath(v, u, tm);
			}
			out[u] = tm;
		}

	public:
		int get_ind_in_path(int u){
			return ind_in_path[u];
		}
		int get_which_path(int u){
			return which_path[u];
		}
		int get_pathtop(int u){
			return pathtop[u];
		}
		int get_dist(int u){
			return dist[u];
		}
		int get_parent(int u){
			return parent[u];
		}
		int get_pathbottom(int u){
			return paths[which_path[u]].back();
		}
		void add_edge(int u, int v){
			G[u].push_back(v), G[v].push_back(u);
		}
		void build(int _root=0){
			root = _root;
			int tm = 0;
			BuildStsize(root, -1);
			pathtop[root] = root;
			dist[root] = 0;
			BuildPath(root, -1, tm);
		}
		//元の頂点のインデックスの配列上でのidを返す
		inline int get(int a){
			return in[a];
		}
		int lca(int a, int b){
			int pa = pathtop[a], pb = pathtop[b];
			while(pathtop[a] != pathtop[b]){
				if(in[pa] > in[pb]){
					a = parent[pa], pa = pathtop[a];
				}else{
					b = parent[pb], pb = pathtop[b];
				}
			}
			if(in[a] > in[b]) swap(a, b);
			return a;
		}
		void subtree_query(int a, const function< void(int, int) > &func){
			func(in[a], out[a]);
		}
		// 例: hl.path_query(q, r, [&](int l, int r){ seg.range(l, r, s); })
		// 例: hl.query(q, r, [&](int l, int r){ ans += seg.query(l, r); })
		void path_query(int a, int b, const function< void(int, int) > &func){
			int pa = pathtop[a], pb = pathtop[b];
			while(pathtop[a] != pathtop[b]){
				if(in[pa] > in[pb]){
					func(in[pa], in[a] + 1);
					a = parent[pa], pa = pathtop[a];
				}else{
					func(in[pb], in[b] + 1);
					b = parent[pb], pb = pathtop[b];
				}
			}
			if(in[a] > in[b]) swap(a, b);
			func(in[a], in[b] + 1);
		}
		HLdecomposition(int node_size) : V(node_size), G(V), stsize(V, 0), parent(V, -1),
		pathtop(V, -1),dist(V), in(V, -1), out(V, -1), ind_in_path(V), which_path(V), paths(1), c(0), d(0){}
};
const int INF = 1e9;  // 適宜調整

int op(int a, int b) {
	    return std::min(a, b);
}

int e() {
	    return INF;
}
int main() {
  int n; cin >> n;
	HLdecomposition HLD(n);
	int u, v;
	rep(i, n-1){
		cin >> u >> v;
		HLD.add_edge(--u, --v);
	}
	HLD.build();
	segtree<int, op, e> seg1(n), seg2(n);
	vector<set<pair<int,int>>> sets(n);
	rep(i, n)sets[i].insert({INF, -1});
	int q; cin >> q;
	vector<pair<int,int>> qs(q);
	rep(i, q){
		int t, a;
		cin >> t >> a;
		a--;
		qs[i] = {t, a};
	}
	rep(i, q){
		auto[t, a] = qs[i];
		if(t == 1){
			pair<int,int> p = {HLD.get_dist(a), a};
			int pos = a;
			while(pos != -1){
				if(sets[pos].count(p))sets[pos].erase(p);
				else sets[pos].insert(p);
			  auto[mind, _] = *sets[pos].begin();
				seg1.set(HLD.get(pos), mind); seg2.set(HLD.get(pos), mind-2*HLD.get_dist(pos));
				pos = HLD.get_parent(HLD.get_pathtop(pos));
			}
		}
		else{
			int ans1 = INF, ans2 = INF;
			int pos = a;
			while(pos != -1){
				int top = HLD.get_pathtop(pos);
				int bot = HLD.get_pathbottom(pos);
				chmin(ans1, seg1.prod(HLD.get(pos), HLD.get(bot)+1)+HLD.get_dist(a)-2*HLD.get_dist(pos));
				chmin(ans2, seg2.prod(HLD.get(top), HLD.get(pos)+1)+HLD.get_dist(a));
				pos = HLD.get_parent(top);
			}
			cout << min(ans1, ans2) << endl;
		}
	}
				
}