#include <bits/stdc++.h>
#pragma optimize("SEX_ON_THE_BEACH")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("fast-math")
#pragma GCC optimize("no-stack-protector")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
using ll = long long int;
using ull = unsigned long long int;
using dd = double;
using ldd = long double;
namespace someUsefull {
template <typename T1, typename T2>
inline void checkMin(T1& a, T2 b) {
  if (a > b) a = b;
}
template <typename T1, typename T2>
inline void checkMax(T1& a, T2 b) {
  if (a < b) a = b;
}
const int _bitfunctions_size_ = 16;
const int _bitfunctions_mask_ = (1 << _bitfunctions_size_) - 1;
char* _bits_count_;
inline void _build_bits_count_() {
  _bits_count_ = new char[1 << _bitfunctions_size_];
  for (int i = 1; i < (1 << _bitfunctions_size_); ++i) {
    _bits_count_[i] = _bits_count_[i >> 1];
    if (i & 1) ++_bits_count_[i];
  }
}
template <typename T1 = char, typename T2 = int>
inline T1 popcnt(T2 x) {
  T1 ans = 0;
  while (x) {
    ans += _bits_count_[x & _bitfunctions_mask_];
    x >>= _bitfunctions_size_;
  }
  return ans;
}
}  // namespace someUsefull
namespace operators {
template <typename T1, typename T2>
std::istream& operator>>(std::istream& in, std::pair<T1, T2>& x) {
  in >> x.first >> x.second;
  return in;
}
template <typename T1, typename T2>
std::ostream& operator<<(std::ostream& out, std::pair<T1, T2> x) {
  out << x.first << " " << x.second;
  return out;
}
template <typename T1>
std::istream& operator>>(std::istream& in, std::vector<T1>& x) {
  for (auto& i : x) in >> i;
  return in;
}
template <typename T1>
std::ostream& operator<<(std::ostream& out, std::vector<T1>& x) {
  for (auto& i : x) out << i << " ";
  return out;
}
}  // namespace operators
using namespace std;
using namespace operators;
using namespace someUsefull;
vector<vector<int>> gr;
vector<pair<int, int>> ed;
vector<int> d;
void dfs(int v, int _d = 0, int p = -1) {
  d[v] = _d;
  for (int to : gr[v]) {
    if (to != p) dfs(to, _d + 1, v);
  }
}
struct Tree {
  const int _size = 1 << 19;
  int n, t;
  vector<pair<int, int>> tree;
  vector<int> upd;
  vector<int> d;
  vector<int> pre;
  vector<int> tin, tout, tos;
  void dfs(int v, int _d = 0, int p = -1) {
    d[v] = _d;
    pre[v] = p;
    tin[v] = tos.size();
    tos.push_back(v);
    for (int to : gr[v]) {
      if (to != p) dfs(to, _d + 1, v);
    }
    tout[v] = tos.size();
  }
  pair<int, int> merge(pair<int, int> a, pair<int, int> b) {
    return {max(a.first, b.first), max(a.second, b.second)};
  }
  Tree(int v) {
    tree.resize(_size << 1, {0, 0});
    upd.resize(_size << 1, 0);
    n = gr.size();
    t = 0;
    d.resize(n);
    tin.resize(n);
    tout.resize(n);
    pre.resize(n);
    0;
    ;
    dfs(v);
    0;
    ;
    for (int i = 0; i < n; ++i) tree[_size + i].first = d[tos[i]];
    for (int i = _size - 1; i > 0; --i)
      tree[i] = merge(tree[i << 1], tree[i << 1 | 1]);
  }
  void change(int v) {
    upd[v] ^= 1;
    swap(tree[v].first, tree[v].second);
  }
  void push(int v) {
    if (!upd[v]) return;
    change(v << 1);
    change(v << 1 | 1);
    upd[v] = 0;
  }
  void update(int v, int l, int r, int fl, int fr) {
    if (r <= l || r <= fl || fr <= l) return;
    if (fl <= l && r <= fr) {
      change(v);
      return;
    }
    push(v);
    update(v << 1, l, (r + l) >> 1, fl, fr);
    update(v << 1 | 1, (r + l) >> 1, r, fl, fr);
    tree[v] = merge(tree[v << 1], tree[v << 1 | 1]);
  }
  int add(int a, int b) {
    if (pre[a] != b) swap(a, b);
    update(1, 0, _size, tin[a], tout[a]);
    return tree[1].first;
  }
};
void solve(int test) {
  int n;
  cin >> n;
  gr.resize(n);
  vector<int> type(n - 1);
  for (int i = 0; i < n - 1; ++i) {
    int a, b;
    cin >> a >> b >> type[i];
    --a;
    --b;
    ed.push_back({a, b});
    gr[a].push_back(b);
    gr[b].push_back(a);
  }
  d.resize(n);
  d.assign(n, -1);
  dfs(0);
  int v = 0;
  for (int i = 0; i < n; ++i)
    if (d[v] < d[i]) v = i;
  dfs(v);
  int L = v;
  int R = 0;
  for (int i = 0; i < n; ++i)
    if (d[R] < d[i]) R = i;
  0;
  ;
  0;
  ;
  Tree LT(L), RT(R);
  0;
  ;
  for (int i = 0; i < n - 1; ++i) {
    if (type[i])
      LT.add(ed[i].first, ed[i].second), RT.add(ed[i].first, ed[i].second);
  }
  int m;
  cin >> m;
  for (int i = 0; i < m; ++i) {
    int x;
    cin >> x;
    --x;
    int ans = 0;
    checkMax(ans, LT.add(ed[x].first, ed[x].second));
    checkMax(ans, RT.add(ed[x].first, ed[x].second));
    cout << ans << '\n';
  }
}
signed main() {
  ios_base::sync_with_stdio(false);
  cout.tie(0);
  cin.tie(0);
  _build_bits_count_();
  cout << setprecision(12) << fixed;
  int t = 1;
  for (int i = 0; i < t; ++i) {
    0;
    ;
    solve(i + 1);
  }
  return 0;
}
