#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
typedef pair<ll, ll> P;

#define each(i,a) for (auto&& i : a)
#define FOR(i,a,b) for (ll i=(a),__last_##i=(b);i<__last_##i;i++)
#define RFOR(i,a,b) for (ll i=(b)-1,__last_##i=(a);i>=__last_##i;i--)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define __GET_MACRO3(_1, _2, _3, NAME, ...) NAME
#define rep(...) __GET_MACRO3(__VA_ARGS__, FOR, REP)(__VA_ARGS__)
#define rrep(...) __GET_MACRO3(__VA_ARGS__, RFOR, RREP)(__VA_ARGS__)
#define pb push_back
#define all(a) (a).begin(),(a).end()
#define chmin(x,v) x = min(x, v)
#define chmax(x,v) x = max(x, v)

const ll linf = 1e18;
const double eps = 1e-12;
const double pi = acos(-1);

template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
    each(x,vec) is >> x;
    return is;
}
template<typename T>
ostream& operator<<(ostream& os, const vector<T>& vec) {
    rep(i,vec.size()) {
        if (i) os << " ";
        os << vec[i];
    }
    return os;
}
template<typename T>
ostream& operator<<(ostream& os, const vector< vector<T> >& vec) {
    rep(i,vec.size()) {
        if (i) os << endl;
        os << vec[i];
    }
    return os;
}
// SegmentTree<ll> seg(n, 0x7FFFFFFF, [](ll a, ll b){return min(a, b);});
class SegmentTree {
    const ll n;
    P find(ll l, ll r, ll node, ll lb, ll ub) {
        if (ub <= l || r <= lb) return P(0, 0);
        if (l <= lb && ub <= r) return P(merge_lazy(node, ub-lb), ub-lb);
        P px = find(l, r, node * 2 + 0, lb, (lb + ub) / 2);
        P py = find(l, r, node * 2 + 1, (lb + ub) / 2, ub);
        return P(merge_lazy(node, px.first + py.first, px.second + py.second), px.second + py.second);
    }
    ll size(ll n) {
        ll res;
        for (res = 1; res < n; res <<= 1);
        return res;
    }
    void add(ll l, ll r, ll node, ll lb, ll ub) {
        if (ub <= l || r <= lb) return;
        if (l <= lb && ub <= r) {
            lazy[node] = !lazy[node];
        }
        else {
            add(l, r, node * 2 + 0, lb, (lb + ub) / 2);
            add(l, r, node * 2 + 1, (lb + ub) / 2, ub);
            data[node] = merge_lazy(node*2+0, (ub-lb)/2) + merge_lazy(node*2+1, (ub-lb)/2);
        }
        // cout << lb << " " << ub << " " << merge_lazy(node, ub-lb) << endl;
        // return merge_lazy(node, ub-lb);
    }
    ll merge_lazy(ll v, ll dt, ll sz) {
        if (lazy[v]) return sz - dt;
        return dt;
    }
    ll merge_lazy(ll v, ll sz) {
        return merge_lazy(v, data[v], sz);
    }
public:
    vector<ll> data, lazy;
    SegmentTree(ll n) :
        n(size(n)), data(size(n) * 2, 0), lazy(size(n) * 2, 0) {}
    void add(ll l, ll r) {
        add(l, r, 1, 0, n);
    }
    ll find(ll l, ll r) {
        return find(l, r, 1, 0, n).first;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    ll n, Q; cin >> n >> Q;
    vector<vector<ll>> chs(n);
    rep(i, 1, n) {
        ll p; cin >> p; --p;
        chs[p].pb(i);
    }
    ll k = 0;
    vector<ll> rrr;
    vector<ll> L(n, -1), R(n, -1);
    function<void(ll)> dfs = [&](ll v) {
        L[v] = k++;
        rrr.pb(v);
        each(to, chs[v]) {
            dfs(to);
        }
        R[v] = k;
    };
    dfs(0);
    SegmentTree seg(n);
    rep(i, n) {
        char c; cin >> c;
        if (c == 'G') {
            seg.add(L[i], L[i]+1);
        }
    }
    // cout << rrr << endl;
    // cout << L << endl;
    // cout << R << endl;
    // cout << endl;
    // cout << seg.data << endl;
    // cout << seg.lazy << endl;
    // cout << endl;
    rep(q, Q) {
        ll v; cin >> v; --v;
        seg.add(L[v], R[v]);
        // cout << seg.find(0, n) << endl;
        if (seg.find(0, n) * 2 >= n) {
            cout << "broccoli" << endl;
        }
        else {
            cout << "cauliflower" << endl;
        }
    }
}



Measured memory_bytes: 19612