#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline bool setmin(T &a, T b) {
  if (a > b) return a = b, 1;
  return 0;
}
template <class T>
inline bool setmax(T &a, T b) {
  if (a < b) return a = b, 1;
  return 0;
}
template <class T>
inline T fast(T a, T b, T mod) {
  long long res = 1;
  while (b) {
    if (b & 1) res = (res * a) % mod;
    a = (a * a) % mod;
    b >>= 1;
  }
  return res;
}
template <class T>
istream &operator>>(istream &os, vector<T> &container) {
  for (auto &u : container) os >> u;
  return os;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &container) {
  for (auto &u : container) os << u << " ";
  return os;
}
template <class T>
inline T gcd(T a, T b) {
  while (b) swap(a %= b, b);
  return abs(a);
}
const long long INF = 1e9 + 7;
const long long mod = 998244353;
const long long BIG_INF = 1e18 + 7;
const long long N = 1e6 + 7;
const long long T = 1 << 19;
const long double inf = 1e18;
const long double eps = 1e-14;
long long n, m, k;
vector<vector<pair<int, int> > > G(N);
int najd = 1, dist, cnt_pre;
vector<int> preorder(N), glebokosc(N), rev_pre(N), kolor(N);
vector<pair<int, int> > przedzial_na_drzewie(N);
struct Tree {
  vector<int> merge(vector<int> &a, vector<int> &b) {
    return {max(a[0], b[0]), max(a[1], b[1])};
  }
  vector<vector<int> > tree;
  vector<int> lazy;
  Tree() {
    tree = vector<vector<int> >(T * 2, vector<int>(2, -1));
    lazy = vector<int>(T * 2, false);
    for (int i = 1; i <= cnt_pre; i++)
      tree[i + T][kolor[rev_pre[i]]] = glebokosc[rev_pre[i]];
    for (int i = T - 1; i >= 0; i--)
      tree[i] = merge(tree[i * 2], tree[i * 2 + 1]);
  };
  void push(int v) {
    if (lazy[v]) {
      swap(tree[v][0], tree[v][1]);
      if (v < T) {
        lazy[v * 2] ^= 1;
        lazy[v * 2 + 1] ^= 1;
      }
      lazy[v] = 0;
    }
  }
  void flip(int a, int b, int u = 1, int lo = 0, int hi = T - 1) {
    push(u);
    if (hi < a or b < lo) return;
    if (a <= lo and hi <= b) {
      lazy[u] ^= 1;
      push(u);
      return;
    }
    int mid = (lo + hi) / 2;
    flip(a, b, u * 2, lo, mid);
    flip(a, b, u * 2 + 1, mid + 1, hi);
    tree[u] = merge(tree[u * 2], tree[u * 2 + 1]);
  }
  void flip(pair<int, int> kraw) {
    int v = (glebokosc[kraw.first] < glebokosc[kraw.second] ? kraw.second
                                                            : kraw.first);
    flip(przedzial_na_drzewie[v].first, przedzial_na_drzewie[v].second);
  }
  int ask() { return tree[1][0]; }
};
void dfs2(int second, int p = -1, int gl = 0, int kol = 0) {
  if (p == -1) cnt_pre = 0;
  preorder[second] = ++cnt_pre;
  rev_pre[cnt_pre] = second;
  glebokosc[second] = gl;
  kolor[second] = kol;
  for (auto &u : G[second])
    if (u.first != p) dfs2(u.first, second, gl + 1, kol ^ u.second);
  przedzial_na_drzewie[second] = {preorder[second], cnt_pre};
}
vector<int> solve(vector<pair<int, int> > &kraw, vector<int> zap, int root) {
  dfs2(root);
  Tree tree;
  vector<int> ret;
  for (auto &u : zap) {
    tree.flip(kraw[u]);
    ret.push_back(tree.ask());
  }
  return ret;
}
void dfs(int second = najd, int gl = 0, int przodek = -1) {
  if (gl == 0) dist = -1;
  if (gl > dist) {
    dist = gl;
    najd = second;
  }
  for (auto &u : G[second])
    if (u.first != przodek) dfs(u.first, gl + 1, second);
}
void solve() {
  cin >> n;
  vector<pair<int, int> > kraw(n, {-1, -1});
  for (int i = 1; i < n; i++) {
    int a, b, c;
    cin >> a >> b >> c;
    G[a].push_back({b, c});
    G[b].push_back({a, c});
    kraw[i] = {a, b};
  }
  vector<int> konce;
  dfs();
  konce.push_back(najd);
  dfs();
  konce.push_back(najd);
  cin >> m;
  vector<int> zapytania(m);
  cin >> zapytania;
  vector<int> A = solve(kraw, zapytania, konce[0]);
  vector<int> B = solve(kraw, zapytania, konce[1]);
  for (int i = 0; i < m; i++) cout << max(A[i], B[i]) << '\n';
}
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int t = 1;
  while (t--) solve();
}
