#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500010;
vector<pair<pair<int, int>, int>> edge;
vector<pair<int, int>> graph[MAXN];
int n, m;
int depth[MAXN], ap, bp;
class SegmentTree {
 public:
  SegmentTree() { cnt = 0; }
  int dfsArr[MAXN];
  int l[MAXN], r[MAXN], f[MAXN], cnt;
  int te[MAXN * 4], to[MAXN * 4];
  int evenLen[MAXN], oddLen[MAXN];
  int lazy[MAXN * 4];
  void build(int p, int curLen, int val, int pop) {
    if (curLen % 2 == 0) {
      this->evenLen[p] = val;
      this->oddLen[p] = 0;
    } else {
      this->oddLen[p] = val;
      this->evenLen[p] = 0;
    }
    l[p] = ++cnt;
    dfsArr[cnt] = p;
    for (auto i : graph[p]) {
      if (i.first == pop) continue;
      f[i.first] = p;
      build(i.first, curLen + i.second, val + 1, p);
    }
    r[p] = cnt;
  }
  void init(int l, int r, int cur) {
    if (l == r) {
      te[cur] = evenLen[dfsArr[l]];
      to[cur] = oddLen[dfsArr[l]];
      return;
    }
    int mid = (l + r) / 2;
    init(l, mid, cur * 2);
    init(mid + 1, r, cur * 2 + 1);
    te[cur] = max(te[cur * 2], te[cur * 2 + 1]);
    to[cur] = max(to[cur * 2], to[cur * 2 + 1]);
  }
  void pushdown(int cur, int l, int r) {
    if (l != r) {
      lazy[cur * 2] += lazy[cur];
      lazy[cur * 2 + 1] += lazy[cur];
      if (lazy[cur] % 2 == 1) {
        swap(te[cur * 2], to[cur * 2]);
        swap(te[cur * 2 + 1], to[cur * 2 + 1]);
      }
    }
    lazy[cur] = 0;
  }
  void change(int l, int r, int tl, int tr, int cur) {
    if (l > tr || r < tl) return;
    pushdown(cur, l, r);
    if (l >= tl && r <= tr) {
      lazy[cur]++;
      swap(te[cur], to[cur]);
    } else {
      int mid = (l + r) / 2;
      change(l, mid, tl, tr, cur * 2);
      change(mid + 1, r, tl, tr, cur * 2 + 1);
      te[cur] = max(te[cur * 2], te[cur * 2 + 1]);
      to[cur] = max(to[cur * 2], to[cur * 2 + 1]);
    }
  }
} t1, t2;
void dfs(int x, int f) {
  for (auto i : graph[x]) {
    if (i.first == f) continue;
    depth[i.first] = depth[x] + 1;
    dfs(i.first, x);
  }
}
void GetDiameter() {
  depth[1] = 0;
  dfs(1, -1);
  int len = -1;
  for (int i = 1; i <= n; i++) {
    if (depth[i] > len) {
      ap = i;
      len = depth[i];
    }
  }
  depth[1] = 0;
  dfs(ap, -1);
  len = -1;
  for (int i = 1; i <= n; i++) {
    if (depth[i] > len) {
      bp = i;
      len = depth[i];
    }
  }
}
void DEBUG(int l, int r, int cur) {
  printf("[%d, %d], lazy: %d even: %d odd: %d\n", l, r, t2.lazy[cur],
         t2.te[cur], t2.to[cur]);
  if (l == r) return;
  int mid = (l + r) / 2;
  DEBUG(l, mid, cur * 2);
  DEBUG(mid + 1, r, cur * 2 + 1);
}
int main() {
  ios::sync_with_stdio(false);
  cin >> n;
  for (int i = 1; i < n; i++) {
    int u, v, w;
    cin >> u >> v >> w;
    edge.push_back(make_pair(make_pair(u, v), w));
    graph[u].push_back(make_pair(v, w));
    graph[v].push_back(make_pair(u, w));
  }
  GetDiameter();
  t1.build(ap, 0, 0, -1);
  t2.build(bp, 0, 0, -1);
  t1.f[ap] = -1;
  t2.f[bp] = -1;
  t1.init(1, n, 1);
  t2.init(1, n, 1);
  cin >> m;
  for (int i = 1; i <= m; i++) {
    int x;
    cin >> x;
    int node = t1.f[edge[x - 1].first.first] == edge[x - 1].first.second
                   ? edge[x - 1].first.first
                   : edge[x - 1].first.second;
    t1.change(1, n, t1.l[node], t1.r[node], 1);
    node = t2.f[edge[x - 1].first.first] == edge[x - 1].first.second
               ? edge[x - 1].first.first
               : edge[x - 1].first.second;
    t2.change(1, n, t2.l[node], t2.r[node], 1);
    int ans = max(t1.te[1], t2.te[1]);
    cout << ans << endl;
  }
  return 0;
}
