package main

import (
	"io"
	"os"
	"strconv"
)

const BS = 300

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func (fs *FastScanner) nextInt() int {
	for fs.idx < fs.n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return sign * val
}

var (
	n, m      int
	par       []int
	size      []int
	heavy     []int
	top       []int
	pos       []int
	tval      []int
	first     []int
	to        []int
	nxt       []int
	raw       []int
	act       []bool
	lazy      []int
	freq      []uint16
	blockBase []int
	blockEnd  []int
	rangeSize int
	offset    int
)

func collectPath(u int, ls []int, rs []int) int {
	k := 0
	for u != 0 {
		tu := top[u]
		if tu == 1 {
			ls[k] = pos[1]
			rs[k] = pos[u]
			k++
			break
		}
		ls[k] = pos[tu]
		rs[k] = pos[u]
		k++
		u = par[tu]
	}
	return k
}

func rangeCountEq(l, r, target int) int {
	if l > r {
		return 0
	}
	bl := l / BS
	br := r / BS
	if bl == br {
		cnt := 0
		lz := lazy[bl]
		for i := l; i <= r; i++ {
			if act[i] && raw[i]+lz == target {
				cnt++
			}
		}
		return cnt
	}
	cnt := 0
	lz := lazy[bl]
	end := blockEnd[bl]
	for i := l; i <= end; i++ {
		if act[i] && raw[i]+lz == target {
			cnt++
		}
	}
	for b := bl + 1; b < br; b++ {
		cnt += int(freq[blockBase[b]+target-lazy[b]+offset])
	}
	lz = lazy[br]
	start := br * BS
	for i := start; i <= r; i++ {
		if act[i] && raw[i]+lz == target {
			cnt++
		}
	}
	return cnt
}

func rangeAdd(l, r, delta int) {
	if l > r {
		return
	}
	bl := l / BS
	br := r / BS
	if bl == br {
		base := blockBase[bl]
		for i := l; i <= r; i++ {
			old := raw[i]
			if act[i] {
				freq[base+old+offset]--
				freq[base+old+delta+offset]++
			}
			raw[i] = old + delta
		}
		return
	}
	base := blockBase[bl]
	end := blockEnd[bl]
	for i := l; i <= end; i++ {
		old := raw[i]
		if act[i] {
			freq[base+old+offset]--
			freq[base+old+delta+offset]++
		}
		raw[i] = old + delta
	}
	for b := bl + 1; b < br; b++ {
		lazy[b] += delta
	}
	base = blockBase[br]
	start := br * BS
	for i := start; i <= r; i++ {
		old := raw[i]
		if act[i] {
			freq[base+old+offset]--
			freq[base+old+delta+offset]++
		}
		raw[i] = old + delta
	}
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data, n: len(data)}

	n = fs.nextInt()
	m = fs.nextInt()

	par = make([]int, n+1)
	first = make([]int, n+1)
	for i := 1; i <= n; i++ {
		first[i] = -1
	}
	to = make([]int, n-1)
	nxt = make([]int, n-1)

	ec := 0
	for i := 2; i <= n; i++ {
		p := fs.nextInt()
		par[i] = p
		to[ec] = i
		nxt[ec] = first[p]
		first[p] = ec
		ec++
	}

	tval = make([]int, n+1)
	for i := 1; i <= n; i++ {
		tval[i] = fs.nextInt()
	}

	size = make([]int, n+1)
	heavy = make([]int, n+1)
	top = make([]int, n+1)
	pos = make([]int, n+1)

	order := make([]int, 0, n)
	stack := make([]int, 1, n)
	stack[0] = 1
	for len(stack) > 0 {
		u := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		order = append(order, u)
		for e := first[u]; e != -1; e = nxt[e] {
			stack = append(stack, to[e])
		}
	}

	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		sz := 1
		hv := 0
		for e := first[u]; e != -1; e = nxt[e] {
			v := to[e]
			sz += size[v]
			if size[v] > size[hv] {
				hv = v
			}
		}
		size[u] = sz
		heavy[u] = hv
	}

	stackU := make([]int, 1, n)
	stackH := make([]int, 1, n)
	stackU[0] = 1
	stackH[0] = 1
	cur := 0
	for len(stackU) > 0 {
		u := stackU[len(stackU)-1]
		h := stackH[len(stackH)-1]
		stackU = stackU[:len(stackU)-1]
		stackH = stackH[:len(stackH)-1]
		for u != 0 {
			top[u] = h
			pos[u] = cur
			cur++
			hv := heavy[u]
			for e := first[u]; e != -1; e = nxt[e] {
				v := to[e]
				if v != hv {
					stackU = append(stackU, v)
					stackH = append(stackH, v)
				}
			}
			u = hv
		}
	}

	rangeSize = 2*n + 1
	offset = n

	numBlocks := (n + BS - 1) / BS
	blockBase = make([]int, numBlocks)
	blockEnd = make([]int, numBlocks)
	lazy = make([]int, numBlocks)
	freq = make([]uint16, numBlocks*rangeSize)

	for b := 0; b < numBlocks; b++ {
		blockBase[b] = b * rangeSize
		e := (b+1)*BS - 1
		if e >= n {
			e = n - 1
		}
		blockEnd[b] = e
	}

	raw = make([]int, n)
	act = make([]bool, n)
	for i := 1; i <= n; i++ {
		p := pos[i]
		raw[p] = -tval[i]
		act[p] = true
		b := p / BS
		freq[blockBase[b]+raw[p]+offset]++
	}

	ans := 0
	out := make([]byte, 0, m*8)
	var ls, rs [64]int

	for i := 0; i < m; i++ {
		q := fs.nextInt()
		if q > 0 {
			u := q
			k := collectPath(par[u], ls[:], rs[:])
			cnt := 0
			for j := 0; j < k; j++ {
				cnt += rangeCountEq(ls[j], rs[j], 0)
			}
			ans += cnt
			for j := 0; j < k; j++ {
				rangeAdd(ls[j], rs[j], 1)
			}
			p := pos[u]
			b := p / BS
			if raw[p]+lazy[b] > 0 {
				ans--
			}
			freq[blockBase[b]+raw[p]+offset]--
			act[p] = false
		} else {
			u := -q
			k := collectPath(par[u], ls[:], rs[:])
			cnt := 0
			for j := 0; j < k; j++ {
				cnt += rangeCountEq(ls[j], rs[j], 1)
			}
			ans -= cnt
			for j := 0; j < k; j++ {
				rangeAdd(ls[j], rs[j], -1)
			}
			p := pos[u]
			b := p / BS
			act[p] = true
			freq[blockBase[b]+raw[p]+offset]++
			if raw[p]+lazy[b] > 0 {
				ans++
			}
		}
		if i > 0 {
			out = append(out, ' ')
		}
		out = strconv.AppendInt(out, int64(ans), 10)
	}
	out = append(out, '\n')
	os.Stdout.Write(out)
}