#include <bits/stdc++.h>
using namespace std;
const int N = 100010, T = 1000;
int n, m, tot, cnt, tp, ans, p[N], head[N], to[N], nxt[N], siz[N], son[N],
    topx[N], dep[N], f[N], t[N], dfn[N], rnk[N], q[N], w[N], clr[N], a[N],
    stk[N], ff[N], fhead[N], fnxt[N], fto[N], idx[N], e[N], ad[T * 2 + 10],
    ct[T * 2 + 10], pt[T * 2 + 10];
vector<pair<int, int> > fp[T * 2 + 10];
vector<int> tt[N * 2];
void add_edge(int u, int v) {
  nxt[++tot] = head[u];
  to[tot] = v;
  head[u] = tot;
  return;
}
void dfs1(int u) {
  siz[u] = 1;
  for (int i = head[u]; ~i; i = nxt[i]) {
    int v = to[i];
    dep[v] = dep[u] + 1;
    dfs1(v);
    siz[u] += siz[v];
    if (siz[v] > siz[son[u]]) son[u] = v;
  }
  return;
}
void dfs2(int u, int tpx) {
  rnk[dfn[u] = ++cnt] = u;
  topx[u] = tpx;
  if (!son[u]) return;
  dfs2(son[u], tpx);
  for (int i = head[u]; ~i; i = nxt[i])
    if (to[i] != son[u]) dfs2(to[i], to[i]);
  return;
}
int LCA(int x, int y) {
  while (topx[x] != topx[y]) {
    if (dep[topx[x]] < dep[topx[y]])
      y = f[topx[y]];
    else
      x = f[topx[x]];
  }
  return dep[x] < dep[y] ? x : y;
}
void dfs(int u) {
  w[u] = clr[u];
  for (int i = head[u]; ~i; i = nxt[i]) {
    int v = to[i];
    dfs(v);
    w[u] += w[v];
  }
  return;
}
bool cmp(int x, int y) { return dfn[x] < dfn[y]; }
void fadd_edge(int u, int v) {
  fnxt[++tot] = head[u];
  fto[tot] = v;
  fhead[u] = tot;
  ff[v] = u;
  e[v] = tot;
  for (int i = f[v]; i != u; i = f[i]) idx[i] = tot;
  return;
}
void build(int l, int r) {
  cnt = tp = tot = 0;
  for (int i = l; i <= r; i++) a[++cnt] = abs(q[i]);
  memset(idx, 0, sizeof(idx));
  a[++cnt] = 1;
  sort(a + 1, a + cnt + 1, cmp);
  cnt = unique(a + 1, a + cnt + 1) - a - 1;
  for (int i = 1; i <= cnt; i++) {
    if (tp <= 1)
      stk[++tp] = a[i];
    else {
      int lca = LCA(a[i], stk[tp]);
      if (lca == stk[tp])
        stk[++tp] = a[i];
      else {
        while (dfn[stk[tp]] > dfn[lca]) {
          if (dfn[stk[tp - 1]] > dfn[lca]) {
            fadd_edge(stk[tp - 1], stk[tp]);
            tp--;
          } else {
            fadd_edge(lca, stk[tp]);
            if (dfn[stk[tp - 1]] == dfn[lca])
              tp--;
            else
              stk[tp] = lca;
            stk[++tp] = a[i];
            break;
          }
        }
      }
    }
  }
  while (tp > 1) {
    fadd_edge(stk[tp - 1], stk[tp]);
    tp--;
  }
  return;
}
int main() {
  memset(head, -1, sizeof(head));
  scanf("%d%d", &n, &m);
  for (int i = 2; i <= n; i++) {
    scanf("%d", f + i);
    add_edge(f[i], i);
  }
  for (int i = 1; i <= n; i++) scanf("%d", t + i);
  dfs1(1);
  dfs2(1, 1);
  for (int i = 1; i <= m; i++) scanf("%d", q + i);
  for (int l = 1; l <= m; l += T) {
    int r = min(m, l + T - 1);
    dfs(1);
    build(l, r);
    for (int i = 1; i <= tot; i++) {
      ct[i] = -1;
      fp[i].clear();
    }
    int mini = 1e9, maxn = 0;
    for (int i = 1; i <= n; i++) {
      w[i] = t[i] - w[i];
      mini = min(mini, w[i]);
    }
    for (int i = 1; i <= n; i++) {
      tt[w[i] - mini].push_back(i);
      maxn = max(maxn, w[i] - mini);
    }
    ans = 0;
    for (int i = 0; i <= maxn; i++) {
      for (auto x : tt[i]) {
        if (!clr[x] && idx[x]) {
          if (ct[idx[x]] == -1 || fp[idx[x]][ct[idx[x]]].first != w[x]) {
            fp[idx[x]].push_back(make_pair(w[x], 0));
            ct[idx[x]]++;
          }
          fp[idx[x]][ct[idx[x]]].second++;
        } else {
          if (w[x] < 0 && !clr[x]) ans++;
        }
      }
    }
    for (int i = 1; i <= tot; i++) {
      pt[i] = -1;
      ad[i] = 0;
      while (pt[i] < ct[i] && fp[i][pt[i] + 1].first < 0) {
        pt[i]++;
        ans += fp[i][pt[i]].second;
      }
    }
    for (int i = l; i <= r; i++) {
      int type = 1;
      if (q[i] < 0) {
        type = 0;
        q[i] = -q[i];
      }
      if (type) {
        clr[q[i]] ^= 1;
        if (w[q[i]] < 0) ans--;
        for (int x = q[i]; x; x = ff[x]) {
          if (e[x]) {
            ad[e[x]]--;
            if (pt[e[x]] < ct[e[x]] &&
                fp[e[x]][pt[e[x]] + 1].first + ad[e[x]] < 0) {
              pt[e[x]]++;
              ans += fp[e[x]][pt[e[x]]].second;
            }
          }
          w[x]--;
          if (!clr[x] && w[x] == -1) ans++;
        }
      } else {
        clr[q[i]] ^= 1;
        if (w[q[i]] < 0) ans++;
        for (int x = q[i]; x; x = ff[x]) {
          if (e[x]) {
            ad[e[x]]++;
            if (pt[e[x]] > -1 && fp[e[x]][pt[e[x]]].first + ad[e[x]] >= 0) {
              ans -= fp[e[x]][pt[e[x]]].second;
              pt[e[x]]--;
            }
          }
          w[x]++;
          if (!clr[x] && w[x] == 0) ans--;
        }
      }
      printf("%d ", ans);
    }
    for (int i = 0; i <= maxn; i++) tt[i].clear();
  }
  return 0;
}
