#include <bits/stdc++.h>

using namespace std;

#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (int)(n); i++)

int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int N, Q;

vector<vector<int>> adj;
vector<char> colors;
vector<int> tour;

// update: range mul
// query: range sum
template <typename T>
struct SqrtDecomposition {
    using int_type = T;
    int N, bucketSize;
    static constexpr int sqrtN = 512;
    vector<int_type> data;
    vector<int_type> bucketMul;
    vector<int_type> bucketSum;

    explicit SqrtDecomposition(const vector<int_type> &data)
        : N(data.size()),
          bucketSize((N + sqrtN - 1) / sqrtN),
          data(data),
          bucketMul(vector<int_type>(bucketSize, 1)),
          bucketSum(vector<int_type>(bucketSize, 0)) {
        rep(i, N) { bucketSum[i / sqrtN] += data[i]; }
    }
    void update(int s, int t, int_type x) {
        rep(i, bucketSize) {
            int l = i * sqrtN, r = l + sqrtN;
            if (r <= s || t <= l) {
                continue;
            }
            // バケット全体
            if (s <= l && r <= t) {
                bucketMul[i] *= x;
            } else {
                for (int j = max(s, l); j < min(t, r); j++) {
                    bucketSum[i] -= data[j];
                    bucketSum[i] += data[j] * x;
                    data[j] *= x;
                }
            }
        }
    }
    int_type getSum(int s, int t) {
        int_type sum = 0;
        rep(i, bucketSize) {
            int l = i * sqrtN, r = l + sqrtN;
            if (r <= s || t <= l) {
                continue;
            }
            // バケット全体
            if (s <= l && r <= t) {
                sum += bucketSum[i] * bucketMul[i];
            } else {
                for (int j = max(s, l); j < min(t, r); j++) {
                    sum += bucketMul[i] * data[j];
                }
            }
        }
        return sum;
    }
    void dump() {
        rep(i, N) cout << data[i] << ", ";
        cout << endl;
        rep(i, sqrtN) cout << bucketMul[i] << ", ";
        cout << endl;
        rep(i, sqrtN) cout << bucketSum[i] << ", ";
        cout << endl;
    }
};

void dfs(int v) {
    tour.push_back(v);
    for (auto u : adj[v]) {
        dfs(u);
    }
    tour.push_back(v);
}
map<int, int> first, last;
int main() {
    cin >> N >> Q;
    adj.resize(N);
    colors.resize(N);
    rep(i, N - 1) {
        int p;
        cin >> p;
        adj[p - 1].push_back(i + 1);
    }
    rep(i, N) cin >> colors[i];

    dfs(0);
    rep(i, tour.size()) {
        if (first.count(tour[i])) {
            first[tour[i]] = min(first[tour[i]], i);
        } else {
            first[tour[i]] = i;
        }
        if (last.count(tour[i])) {
            last[tour[i]] = max(last[tour[i]], i);
        } else {
            last[tour[i]] = i;
        }
    }
    // for(auto x: tour) cout << x << ", ";
    // cout << endl;
    vector<long long> vec(tour.size(), 0);
    for (auto e : first) {
        if (colors[e.first] == 'G') vec[e.second] = 1;
        else vec[e.second] = -1;
        // cout << e.first << ", " << e.second << " = " << vec[e.second] << endl;
    }
    SqrtDecomposition<long long> sd(vec);
    while (Q--) {
        int v;
        cin >> v;
        v--;
        sd.update(first[v], last[v], -1);
        // cout << "update: " << first[v] << ", " << last[v] << endl;
        long long cnt = sd.getSum(0, tour.size());
        cout << ((cnt > 0) ? "broccoli" : "cauliflower") << endl;
        // cout << cnt << ", " << N << endl;
    }
    return 0;
}



Measured memory_bytes: 26260