#include <bits/stdc++.h>
using namespace std;

using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;

#define ALL(a)  begin((a)),end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)

#define FF first
#define SS second

#define DUMP(x) cout<<#x<<":"<<(x)<<endl
template<class S, class T>
istream& operator>>(istream& is, pair<S,T>& p){
  return is >> p.FF >> p.SS;
}
template<class T>
istream& operator>>(istream& is, vector<T>& xs){
  for(auto& x: xs)
	is >> x;
  return is;
}
template<class S, class T>
ostream& operator<<(ostream& os, const pair<S,T>& p){
  return os << p.FF << " " << p.SS;
}
template<class T>
ostream& operator<<(ostream& os, const vector<T>& xs){
  for(unsigned int i=0;i<xs.size();++i)
	os << (i?" ":"") << xs[i];
  return os;
}
template<class T>
void maxi(T& x, T y){
  if(x < y) x = y;
}
template<class T>
void mini(T& x, T y){
  if(x > y) x = y;
}


const double EPS = 1e-10;
const double PI  = acos(-1.0);
const LL MOD = 1e9+7;

const string B = "broccoli";
const string W = "cauliflower";
const int MAX = 1e5+10;

int sz[MAX];
void init(int u, int& t, VVI& G, VI& in, VI& out, VI& order){
  sz[u] = 1;
  order[t] = u;
  in[u] = t++;
  
  for(int to: G[u]){
	init(to, t, G, in, out, order);
	sz[u] += sz[to];
  }

  out[u] = t;
}

class LazySegT{
private:
  int NN, N;
  struct Node{
	int dat;
	int lazy;
  };
  Node segT[2*(1<<19)-1];
public:
  LazySegT(int n, vector<bool>& poi, VI& ord): N(n){
	NN = 1;
	while(NN < n) NN <<= 1;
	for(int i=0;i<2*NN-1;++i)
	  segT[i].dat = 0, segT[i].lazy = 0;

	REP(i,N)
	  segT[i+NN-1].dat = poi[ord[i]];

	for(int i=NN-2;i>=0;--i){
	  segT[i].dat = segT[i*2+1].dat + segT[i*2+2].dat;
	}
  }

  void eval(int k, int l, int r){
	if(segT[k].lazy <= 0) return;
	
	segT[k].dat = r-l - segT[k].dat;
	if(k < NN-1){ // not leaf
	  segT[2*k+1].lazy ^= segT[k].lazy;
	  segT[2*k+2].lazy ^= segT[k].lazy;
	}
	segT[k].lazy = 0;
  }

  void update(int a, int b, int k, int l, int r){
	eval(k,l,r);
	if(r <= a || b <= l) return;

	if(a <= l && r <= b){
	  segT[k].lazy ^= 1;
	  eval(k,l,r);
	}
	else{
	  update(a, b, k*2+1, l, (l+r)/2);
	  update(a, b, k*2+2, (l+r)/2, r);
	  segT[k].dat = segT[k*2+1].dat + segT[k*2+2].dat;
	}
  }

  void update(int a, int b){
	update(a, b, 0, 0, NN);
  }

  int query(int a, int b, int k, int l, int r){
	eval(k,l,r);
	if(r <= a || b <= l) return 0;

	if(a <= l && r <= b) return segT[k].dat;
	else{
	  int vl = query(a, b, k*2+1, l, (l+r)/2);
	  int vr = query(a, b, k*2+2, (l+r)/2, r);
	  segT[k].dat = segT[k*2+1].dat + segT[k*2+2].dat;
	  return vl+vr;
	}
  }
  int query(){
	return query(0, N, 0, 0, NN);
  }

  void dump(){
	REP(i,N) cout << query(i, i+1, 0, 0, NN) << " ";
	cout << endl;
  }
};

int main(){
  cin.tie(0);
  ios_base::sync_with_stdio(false);

  int N, Q;
  cin >> N >> Q;

  VVI chd(N);
  REP(i,N-1){
	int p;
	cin >> p;
	--p;
	chd[p].PB(i+1);
  }
  vector<bool> pyon(N);
  REP(i,N){
	char c;
	cin >> c;
	pyon[i] = c=='G';
  }

  int tm = 0;
  VI in(N), out(N), ord(N);
  init(0, tm, chd, in, out, ord);

  LazySegT seg(N, pyon, ord);
  //seg.dump();
  REP(q,Q){
	int u;
	cin >> u;
	--u;
	seg.update(in[u], out[u]);
	int n = seg.query();
	cout << (n > N-n?B:W) << endl;
	//seg.dump();
  }

  return 0;
}



Measured memory_bytes: 21372