#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb emplace_back
#define INF (1e9+1)
#define MAX_V 100000

//0-index 抽象化半開区間遅延セグツリー
template<typename T, typename E>
class segment_tree{
    typedef function<T(T,T)> F; //要素に適用する演算
    typedef function<T(T,E)> G; //作用素の適用
    typedef function<E(E,E)> H; //作用素の合成
    typedef function<E(E,int)> P;
private:
    int num_of_elm_;
    vector<T> dat_, lazy_;
    F f_;
    G g_;
    H h_;
    P p_;
    T ident_;
    E op_ident_;
public:
    segment_tree(int n, F f, G g, H h, P p, T ident, E op_ident):f_(f), g_(g), h_(h), p_(p), ident_(ident), op_ident_(op_ident){
        num_of_elm_ = 1;
        while(num_of_elm_<n)num_of_elm_*=2;
        dat_ .resize(2*num_of_elm_,ident);
        lazy_.resize(2*num_of_elm_,op_ident);
    }
    
    void build(vector<T> vec){
        rep(i,vec.size()) dat_[num_of_elm_+i] = vec[i];
        for(int i=num_of_elm_-1;i>=1;i--)dat_[i] = f_(dat_[i*2],dat_[i*2+1]);
    }
    
    void eval(int k, int len){
        if(lazy_[k] == op_ident_)return ;
        
        if(k<num_of_elm_){
            lazy_[k*2]=h_(lazy_[k*2], lazy_[k]);
            lazy_[k*2+1]=h_(lazy_[k*2+1], lazy_[k]);
        }
        dat_[k] = g_(dat_[k],p_(lazy_[k], len));
        lazy_[k] = op_ident_;
    }
    
    T update(int L, int R, int val, int l=0, int r=0, int k=1){
        if(k==1)r = num_of_elm_;
        
        eval(k,r-l);
        if(r<=L || R<=l)return dat_[k];
        else if(L<=l && r<=R){
            lazy_[k] = h_(lazy_[k], val);
            return g_(dat_[k], p_(lazy_[k], r-l));
        }
        else{
            return dat_[k] = f_(update(L,R,val,l,(l+r)/2,k*2), update(L,R,val,(l+r)/2,r,k*2+1));
        }
        
    }
    
    T query(int L, int R,int l=0,int r=0, int k=1){
        if(k==1)r = num_of_elm_;
        
        eval(k,r-l);
        if(r<=L || R<=l)return ident_;
        else if(L<=l && r<=R){
            return dat_[k];
        }
        else{
            return f_(query(L,R,l,(l+r)/2,k*2), query(L,R,(l+r)/2,r,k*2+1));
        }
    }
};


void eular_tour(int cur, vector<int> &vs, vector<int> G[MAX_V]){
    vs.pb(cur);
    for(auto elm:G[cur]){
        eular_tour(elm,vs,G);
    }
    vs.pb(cur);
}

int main(){
    vector<int> G[MAX_V];
    
    int n,q;
    cin>>n>>q;
    for(int i=1;i<n;i++){
        int p;
        cin>>p;
        G[p-1].pb(i);
    }
    vector<int> vs;
    eular_tour(0,vs,G);
    vector<int> pr(n,-1),bk(n,-1);
    rep(i,vs.size()){
        if(pr[vs[i]]==-1)pr[vs[i]] = i;
        else bk[vs[i]] = i;
    }

    vector<int> v(2*n);
    vector<int> inp(n);
    rep(i,n){
        char ch;
        cin>>ch;
        if(ch=='G')inp[i] = 1;
        else inp[i] = -1;
    }
    rep(i,pr.size()) v[pr[i]] = inp[i];
    rep(i,bk.size()) v[bk[i]] = inp[i];

    auto f = [](int a,int b){return a+b;};
    auto g = [](int a,int b){return a*b;};
    auto h = g;
    auto p = [](int a,int len){return a;};
    segment_tree<int,int> st(2*n, f, g, h, p, 0, 1);
    st.build(v);
    
    
    rep(i,q){
        int x;
        cin>>x;
        x--;
        st.update(pr[x],bk[x]+1,-1);
        int res = st.query(0,2*n);
        if(res>0)cout<<"broccoli"<<endl;
        else cout<<"cauliflower"<<endl;
        
    }
}



Measured memory_bytes: 22252