```go
package main

import "fmt"

type SegTree struct {
	tree []int64
	lazy []bool
	n    int
}

func NewSegTree(arr []int) *SegTree {
	n := len(arr)
	st := &SegTree{
		tree: make([]int64, 4*n),
		lazy: make([]bool, 4*n),
		n:    n,
	}
	st.build(1, 0, n-1, arr)
	return st
}

func (st *SegTree) build(node, start, end int, arr []int) {
	if start == end {
		st.tree[node] = int64(arr[start])
		return
	}
	mid := (start + end) / 2
	st.build(2*node, start, mid, arr)
	st.build(2*node+1, mid+1, end, arr)
	st.tree[node] = st.tree[2*node] + st.tree[2*node+1]
}

func (st *SegTree) propagate(node, start, end int) {
	if st.lazy[node] {
		st.tree[node] = int64(end-start+1) - st.tree[node]
		if start != end {
			st.lazy[2*node] = !st.lazy[2*node]
			st.lazy[2*node+1] = !st.lazy[2*node+1]
		}
		st.lazy[node] = false
	}
}

func (st *SegTree) update(node, start, end, l, r int) {
	st.propagate(node, start, end)
	if start > end || start > r || end < l {
		return
	}
	if l <= start && end <= r {
		st.lazy[node] = !st.lazy[node]
		st.propagate(node, start, end)
		return
	}
	mid := (start + end) / 2
	st.update(2*node, start, mid, l, r)
	st.update(2*node+1, mid+1, end, l, r)
	st.tree[node] = st.tree[2*node] + st.tree[2*node+1]
}

func (st *SegTree) Update(l, r int) {
	st.update(1, 0, st.n-1, l, r)
}

func (st *SegTree) query(node, start, end, l, r int) int64 {
	st.propagate(node, start, end)
	if start > end || start > r || end < l {
		return 0
	}
	if l <= start && end <= r {
		return st.tree[node]
	}
	mid := (start + end) / 2
	p1 := st.query(2*node, start, mid, l, r)
	p2 := st.query(2*node+1, mid+1, end, l, r)
	return p1 + p2
}

func (st *SegTree) Query(l, r int) int64 {
	return st.query(1, 0, st.n-1, l, r)
}

func main() {
	var n int
	fmt.Scan(&n)
	adj := make([][]int, n+1)
	for i := 2; i <= n; i++ {
		var pi int
		fmt.Scan(&pi)
		adj[pi] = append(adj[pi], i)
	}
	t := make([]int, n+1)
	for i := 1; i <= n; i++ {
		fmt.Scan(&t[i])
	}
	inTime := make([]int, n+1)
	outTime := make([]int, n+1)
	order := make([]int, n)
	timer := 0
	var dfs func(int, int)
	dfs = func(u, par int) {
		inTime[u] = timer
		order[timer] = t[u]
		timer++
		for _, v := range adj[u] {
			if v != par {
				dfs(v, u)
			}
		}
		outTime[u] = timer
	}
	dfs(1, 0)
	st := NewSegTree(order)
	var q int
	fmt.Scan(&q)
	for i := 0; i < q; i++ {
		var op string
		var v int
		fmt.Scan(&op, &v)
		L := inTime[v]
		R := outTime[v] - 1
		if op == "pow" {
			st.Update(L, R)
		} else {
			fmt.Println(st.Query(L, R))
		}
	}
}
```