#include <bits/stdc++.h>
using namespace std;
void check(bool q) {
  if (!q) {
    throw 1;
  }
}
struct Node {
  int countLight;
  int length;
  bool changed;
  Node(bool light = 0) : countLight(light), length(1), changed(false) {}
  Node(int countLight, int length, bool changed)
      : countLight(countLight), length(length), changed(changed) {}
  void inverse() {
    countLight = length - countLight;
    changed = !changed;
  }
};
Node combine(const Node& a, const Node& b) {
  return Node(a.countLight + b.countLight, a.length + b.length, false);
}
struct SegmentTree {
  int nElements;
  vector<Node> tree;
  void build(int v, int l, int r, const vector<bool>& arr) {
    if (l == r) {
      tree[v] = Node(arr[l]);
    } else {
      int m = (l + r) / 2;
      build(2 * v + 1, l, m, arr);
      build(2 * v + 2, m + 1, r, arr);
      tree[v] = combine(tree[2 * v + 1], tree[2 * v + 2]);
    }
  }
  void push(int v) {
    if (tree[v].changed) {
      tree[2 * v + 1].inverse();
      tree[2 * v + 2].inverse();
      tree[v].changed = false;
    }
  }
  Node get(int v, int tl, int tr, int ql, int qr) {
    if (tl == ql && tr == qr) {
      return tree[v];
    } else {
      push(v);
      int tm = (tl + tr) / 2;
      if (qr <= tm) {
        return get(2 * v + 1, tl, tm, ql, qr);
      } else if (ql > tm) {
        return get(2 * v + 2, tm + 1, tr, ql, qr);
      } else {
        return combine(get(2 * v + 1, tl, tm, ql, tm),
                       get(2 * v + 2, tm + 1, tr, tm + 1, qr));
      }
    }
  }
  int get(int l, int r) { return get(0, 0, nElements - 1, l, r).countLight; }
  void update(int v, int tl, int tr, int ql, int qr) {
    if (tl == ql && tr == qr) {
      tree[v].inverse();
    } else {
      push(v);
      int tm = (tl + tr) / 2;
      if (qr <= tm) {
        update(2 * v + 1, tl, tm, ql, qr);
      } else if (ql > tm) {
        update(2 * v + 2, tm + 1, tr, ql, qr);
      } else {
        update(2 * v + 1, tl, tm, ql, tm);
        update(2 * v + 2, tm + 1, tr, tm + 1, qr);
      }
      tree[v] = combine(tree[2 * v + 1], tree[2 * v + 2]);
    }
  }
  void update(int l, int r) { update(0, 0, nElements - 1, l, r); }
  SegmentTree(const vector<bool>& arr) {
    nElements = (int)arr.size();
    int pow = 1;
    while (pow < nElements) {
      pow *= 2;
    }
    tree.assign(2 * pow, {});
    build(0, 0, nElements - 1, arr);
  }
};
int main() {
  int nVertex;
  scanf("%d", &nVertex);
  vector<vector<int>> edges(1 + nVertex);
  for (int curr = 2; curr <= nVertex; ++curr) {
    int parent;
    scanf("%d", &parent);
    edges[parent].push_back(curr);
  }
  vector<bool> light(1 + nVertex, false);
  for (int i = 1; i <= nVertex; ++i) {
    int value;
    scanf("%d", &value);
    light[i] = (value == 1);
  }
  vector<bool> arr;
  vector<int> subVert;
  vector<pair<int, int>> segments(1 + nVertex);
  function<void(int)> visit = [&](int curr) {
    arr.push_back(light[curr]);
    subVert.push_back(curr);
    segments[curr].first = (int)arr.size() - 1;
    for (int next : edges[curr]) {
      visit(next);
    }
    segments[curr].second = (int)arr.size() - 1;
  };
  visit(1);
  SegmentTree st(arr);
  int q;
  scanf("%d", &q);
  for (int i = 0; i < q; ++i) {
    char buf[3 + 1];
    int vert;
    scanf("%3s %d", buf, &vert);
    string s(buf);
    check(s == "pow" || s == "get");
    auto& seg = segments[vert];
    if (s == "pow") {
      st.update(seg.first, seg.second);
    } else {
      printf("%d\n", st.get(seg.first, seg.second));
    }
  }
  return 0;
}
