#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <chrono>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// element to erase must exist
template <class T> struct MinPQue {
  priority_queue<T, vector<T>, greater<T>> que0, que1;
  int size() const { return que0.size() - que1.size(); }
  void push(const T &t) { que0.push(t); }
  void erase(const T &t) { que1.push(t); }
  void reduce() { for (; que0.size() && que1.size() && que0.top() == que1.top(); que0.pop(), que1.pop()) {} }
  const T &top() { reduce(); return que0.top(); }
  void pop() { reduce(); que0.pop(); }
};
template <class T> struct MaxPQue {
  priority_queue<T> que0, que1;
  int size() const { return que0.size() - que1.size(); }
  void push(const T &t) { que0.push(t); }
  void erase(const T &t) { que1.push(t); }
  void reduce() { for (; que0.size() && que1.size() && que0.top() == que1.top(); que0.pop(), que1.pop()) {} }
  const T &top() { reduce(); return que0.top(); }
  void pop() { reduce(); que0.pop(); }
};


int N;
vector<vector<int>> graph;

vector<int> sz, del;
void dfsSz(int u, int p) {
  sz[u] = 1;
  for (const int v : graph[u]) if (p != v) {
    dfsSz(v, u);
    sz[u] += sz[v];
  }
}
string dfsString(int u, int p) {
  ostringstream oss;
  oss << "[" << u;
  for (const int v : graph[u]) if (!del[v] && p != v) {
    oss << " " << dfsString(v, u);
  }
  oss << "]";
  return oss.str();
}
/// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

vector<vector<pair<int, int>>> rdss;
void dfs(int r, int u, int p, int d) {
  rdss[u].emplace_back(r, d);
  for (const int v : graph[u]) if (p != v && !del[v]) {
    dfs(r, v, u, d + 1);
  }
}

/// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
void solveSubtree(int depth, int r) {
#ifdef LOCAL
  cerr << string(2 * depth, ' ') << "solveSubtree " << dfsString(r, -1) << endl;
#endif
  vector<int> vs;
  for (const int v : graph[r]) if (!del[v]) {
    vs.push_back(v);
  }
  const int len = vs.size();
  /// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  dfs(r, r, -1, 0);
  /// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
}
void solveRec(int depth, int u) {
  for (; ; ) {
    int vm = -1;
    for (const int v : graph[u]) if (!del[v]) {
      if (!~vm || sz[vm] < sz[v]) {
        vm = v;
      }
    }
    if (!~vm || 2 * sz[vm] <= sz[u]) {
      solveSubtree(depth, u);
      del[u] = 1;
      for (const int v : graph[u]) if (!del[v]) {
        solveRec(depth + 1, v);
      }
      break;
    } else {
      sz[u] -= sz[vm];
      sz[vm] += sz[u];
      u = vm;
    }
  }
}
void centroidDecomp() {
  sz.assign(N, 0);
  dfsSz(0, -1);
  del.assign(N, 0);
  
  rdss.assign(N, {});
  
  solveRec(0, 0);
}



int main() {
  for (; ~scanf("%d", &N); ) {
    vector<int> A(N - 1), B(N - 1);
    for (int i = 0; i < N - 1; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
    }
    
    graph.assign(N, {});
    for (int i = 0; i < N - 1; ++i) {
      graph[A[i]].push_back(B[i]);
      graph[B[i]].push_back(A[i]);
    }
    centroidDecomp();
//cerr<<"rdss = "<<rdss<<endl;
    
    vector<int> colors(N, 0);
    vector<MinPQue<int>> ques(N);
    
    int Q;
    scanf("%d", &Q);
    for (; Q--; ) {
      int O, U;
      scanf("%d%d", &O, &U);
      --U;
      if (O == 1) {
        colors[U] ^= 1;
        if (colors[U]) {
          for (const auto &rd : rdss[U]) ques[rd.first].push(rd.second);
        } else {
          for (const auto &rd : rdss[U]) ques[rd.first].erase(rd.second);
        }
      } else if (O == 2) {
        int ans = N;
        for (const auto &rd : rdss[U]) if (ques[rd.first].size()) {
          chmin(ans, ques[rd.first].top() + rd.second);
        }
        printf("%d\n", ans);
      } else {
        assert(false);
      }
    }
  }
  return 0;
}