#include <bits/stdc++.h>
const int MAXN = 6e5;
int n, m, root, tim, edge;
int U[MAXN | 1], V[MAXN | 1], W[MAXN | 1], dfn[MAXN | 1], size[MAXN | 1],
    xorv[MAXN | 1], ID[MAXN | 1], depth[MAXN | 1], fst[MAXN | 1], ans[MAXN | 1];
std::vector<int> que;
struct Edge {
  int to, w, nxt;
  Edge(int _to = 0, int _w = 0, int _nxt = 0) : to(_to), w(_w), nxt(_nxt) {}
} e[MAXN << 1];
inline int read() {
  register int x = 0, v = 1;
  register char ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') v = -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return x * v;
}
inline void add_edge(int a, int b, int c) {
  e[++edge] = Edge(b, c, fst[a]);
  fst[a] = edge;
}
int BFS(int x) {
  int ans = 1;
  bool vis[MAXN | 1];
  std::queue<int> q;
  memset(vis, 0, sizeof(vis));
  q.push(x);
  vis[x] = 1;
  do {
    int from = q.front();
    q.pop();
    ans = from;
    for (int k = fst[from]; k; k = e[k].nxt) {
      int to = e[k].to;
      if (vis[to]) continue;
      vis[to] = 1;
      q.push(to);
    }
  } while (!q.empty());
  return ans;
}
void dfs(int x, int fa) {
  ID[dfn[x] = ++tim] = x;
  size[x] = 1;
  depth[x] = depth[fa] + 1;
  for (int k = fst[x]; k; k = e[k].nxt) {
    int to = e[k].to, w = e[k].w;
    if (to == fa) continue;
    xorv[to] = xorv[x] ^ w;
    dfs(to, x);
    size[x] += size[to];
  }
}
namespace SegmentTree {
int max0[MAXN << 2 | 1], max1[MAXN << 1 | 1], tag[MAXN << 1 | 1];
void push_up(int o) {
  max0[o] = std::max(max0[o << 1], max0[o << 1 | 1]);
  max1[o] = std::max(max1[o << 1], max1[o << 1 | 1]);
}
void push_down(int o) {
  if (!tag[o]) return;
  std::swap(max0[o << 1], max1[o << 1]);
  std::swap(max0[o << 1 | 1], max1[o << 1 | 1]);
  tag[o << 1] ^= 1;
  tag[o << 1 | 1] ^= 1;
  tag[o] = 0;
}
void build(int o, int l, int r) {
  tag[o] = 0;
  max0[o] = max1[o] = 0;
  if (l == r) {
    if (xorv[ID[l]])
      max1[o] = depth[ID[l]];
    else
      max0[o] = depth[ID[l]];
    return;
  }
  int mid = (l + r) >> 1;
  build(o << 1, l, mid);
  build(o << 1 | 1, mid + 1, r);
  push_up(o);
}
void flip(int o, int l, int r, int ql, int qr) {
  if (ql <= l && r <= qr) {
    std::swap(max0[o], max1[o]);
    tag[o] ^= 1;
    return;
  }
  int mid = (l + r) >> 1;
  push_down(o);
  if (ql <= mid) flip(o << 1, l, mid, ql, qr);
  if (mid < qr) flip(o << 1 | 1, mid + 1, r, ql, qr);
  push_up(o);
}
int query(int o, int l, int r, int ql, int qr) {
  if (ql <= l && r <= qr) return max1[o];
  int mid = (l + r) >> 1, res = 0;
  push_down(o);
  if (ql <= mid) res = query(o << 1, l, mid, ql, qr);
  if (mid < qr) res = std::max(res, query(o << 1 | 1, mid + 1, r, ql, qr));
  return res;
}
}  // namespace SegmentTree
using namespace SegmentTree;
int main() {
  n = read();
  for (int i = 1; i < n; ++i) {
    U[i] = read();
    V[i] = read();
    W[i] = read();
    add_edge(U[i], V[i], W[i]);
    add_edge(V[i], U[i], W[i]);
  }
  root = BFS(1);
  int lst = root;
  dfs(root, 0);
  build(1, 1, n);
  m = read();
  for (int i = 1; i <= m; ++i) {
    int x = read(), u = U[x], v = V[x];
    que.push_back(x);
    if (depth[u] < depth[v]) std::swap(u, v);
    flip(1, 1, n, dfn[u], dfn[u] + size[u] - 1);
    ans[i] = max0[1] - 1;
  }
  root = BFS(root);
  xorv[root] = 0;
  tim = 0;
  dfs(root, 0);
  build(1, 1, n);
  for (int i = 1; i <= m; ++i) {
    int x = que[i - 1], u = U[x], v = V[x];
    if (depth[u] < depth[v]) std::swap(u, v);
    flip(1, 1, n, dfn[u], dfn[u] + size[u] - 1);
    ans[i] = std::max(max0[1] - 1, ans[i]);
  }
  for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
  return 0;
}
