#include <bits/stdc++.h>
using namespace std;
int numb = 0;
vector<int> segment(1000000);
vector<bool> has_to_change(1000000);
void dfs(int cur, const vector<vector<int>>& spis, vector<int>& posl,
         vector<int>& tin, vector<int>& tout) {
  ++numb;
  posl.push_back(cur);
  tin[cur] = numb;
  for (int i = 0; i < spis[cur].size(); ++i) {
    dfs(spis[cur][i], spis, posl, tin, tout);
  }
  tout[cur] = numb;
  return;
}
void build_segment_tree(const vector<int>& znach, int num, int tl, int tr) {
  if (tl == tr) {
    segment[num] = znach[tl];
  } else {
    if (tl > tr) {
      return;
    }
    int tm = (tl + tr) / 2;
    build_segment_tree(znach, 2 * num + 1, tl, tm);
    build_segment_tree(znach, 2 * num + 2, tm + 1, tr);
    segment[num] = segment[2 * num + 1] + segment[2 * num + 2];
  }
}
void flip(int num, int tl, int tr, int now_l, int now_r) {
  if ((now_l > tr) || (now_r < tl)) {
    return;
  }
  if (now_l > now_r) {
    return;
  }
  if ((now_l >= tl) && (now_r <= tr)) {
    if (has_to_change[num] == true) {
      has_to_change[num] = false;
    } else {
      has_to_change[num] = true;
    }
    return;
  }
  int mid = (now_l + now_r) / 2;
  flip(2 * num + 1, tl, tr, now_l, mid);
  int q1, q2;
  if (has_to_change[2 * num + 1]) {
    q1 = mid - now_l + 1 - segment[2 * num + 1];
  } else {
    q1 = segment[2 * num + 1];
  }
  flip(2 * num + 2, tl, tr, mid + 1, now_r);
  if (has_to_change[2 * num + 2]) {
    q2 = now_r - (mid + 1) + 1 - segment[2 * num + 2];
  } else {
    q2 = segment[2 * num + 2];
  }
  segment[num] = q1 + q2;
}
int get_ans(int num, int tl, int tr, int now_l, int now_r) {
  if (now_l > now_r) {
    return 0;
  }
  if ((now_r < tl) || (now_l > tr)) {
    return 0;
  }
  if (now_l == now_r) {
    if (has_to_change[num]) {
      segment[num] = 1 - segment[num];
      has_to_change[num] = false;
    }
    return segment[num];
  }
  if (has_to_change[num] == true) {
    has_to_change[num] = false;
    if (2 * num + 1 < segment.size()) {
      if (has_to_change[2 * num + 1] == true) {
        has_to_change[2 * num + 1] = false;
      } else {
        has_to_change[2 * num + 1] = true;
      }
    }
    if (2 * num + 2 < segment.size()) {
      if (has_to_change[2 * num + 2] == true) {
        has_to_change[2 * num + 2] = false;
      } else {
        has_to_change[2 * num + 2] = true;
      }
    }
    segment[num] = (now_r - now_l + 1) - segment[num];
  }
  if ((now_l >= tl) && (now_r <= tr)) {
    return segment[num];
  } else {
    int mid = (now_l + now_r) / 2;
    int r1 = get_ans(2 * num + 1, tl, tr, now_l, mid);
    int r2 = get_ans(2 * num + 2, tl, tr, mid + 1, now_r);
    return (r1 + r2);
  }
}
int main() {
  int n;
  cin >> n;
  vector<vector<int>> spis(n);
  for (int i = 1; i < n; ++i) {
    int k;
    cin >> k;
    --k;
    spis[k].push_back(i);
  }
  vector<int> posl;
  vector<int> tin(n);
  vector<int> tout(n);
  dfs(0, spis, posl, tin, tout);
  for (int i = 0; i < n; ++i) {
  }
  vector<int> if_open(n);
  for (int i = 0; i < n; ++i) {
    cin >> if_open[i];
  }
  vector<int> if_open2(n);
  for (int i = 0; i < n; ++i) {
    if_open2[i] = if_open[posl[i]];
  }
  for (int i = 0; i < n; ++i) {
  }
  build_segment_tree(if_open2, 0, 0, n - 1);
  for (int i = 0; i < 4 * n; ++i) {
  }
  int q;
  cin >> q;
  for (int i = 0; i < q; ++i) {
    string s;
    int l;
    cin >> s >> l;
    if (s == "get") {
      long long kol = get_ans(0, tin[l - 1] - 1, tout[l - 1] - 1, 0, n - 1);
      cout << kol << endl;
    } else {
      flip(0, tin[l - 1] - 1, tout[l - 1] - 1, 0, n - 1);
    }
  }
}
