#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const int inf = 1e9;
int n, idx, st[2][N], en[2][N], cnt, f[2][N];
pair<int, int> edge[2][N];
vector<int> g[2][N];
vector<pair<int, int> > Edge, Temp;
set<pair<int, int> > ele[2][N];
pair<int, int> it[2][2][4 * N];
pair<int, int> init[2];
bool inAns[2][N];
void update(int dir, int type, int k, int l, int r, int L, int R,
            pair<int, pair<int, int> > val) {
  if (r < L || R < l || L > R) return;
  if (L <= l && r <= R) {
    if (val.first == 0)
      ele[type][l].insert(val.second);
    else
      ele[type][l].erase(val.second);
    if (!dir) {
      if (!ele[type][l].empty())
        it[dir][type][k] = *ele[type][l].begin();
      else
        it[dir][type][k] = {inf, 0};
    } else {
      if (!ele[type][l].empty())
        it[dir][type][k] = *(--ele[type][l].end());
      else
        it[dir][type][k] = {0, 0};
    }
    return;
  }
  int md = (l + r) >> 1;
  update(dir, type, k << 1, l, md, L, R, val);
  update(dir, type, k << 1 | 1, md + 1, r, L, R, val);
  if (!dir)
    it[dir][type][k] = min(it[dir][type][k << 1], it[dir][type][k << 1 | 1]);
  else
    it[dir][type][k] = max(it[dir][type][k << 1], it[dir][type][k << 1 | 1]);
}
pair<int, int> get(int dir, int type, int k, int l, int r, int L, int R) {
  if (r < L || R < l || L > R) return init[dir];
  if (L <= l && r <= R) return it[dir][type][k];
  int md = (l + r) >> 1;
  if (!dir)
    return min(get(dir, type, k << 1, l, md, L, R),
               get(dir, type, k << 1 | 1, md + 1, r, L, R));
  else
    return max(get(dir, type, k << 1, l, md, L, R),
               get(dir, type, k << 1 | 1, md + 1, r, L, R));
}
void dfs(int type, int u, int p) {
  st[type][u] = ++cnt;
  for (int i = 0; i < g[type][u].size(); i++) {
    int v = g[type][u][i];
    if (v == p) continue;
    f[type][v] = f[type][u] + 1;
    dfs(type, v, u);
  }
  en[type][u] = cnt;
}
void print(int type) { cout << (type == 0 ? "Blue" : "Red") << "\n"; }
int main() {
  cin.tie(0), ios_base::sync_with_stdio(0);
  cin >> n;
  for (int type = 0; type < 2; type++) {
    for (int k = 0; k < 4 * n; k++) it[0][type][k] = {inf, 0};
  }
  init[0] = {inf, 0}, init[1] = {0, 0};
  for (int j = 0; j < 2; j++) {
    for (int i = 2; i <= n; i++) {
      int x;
      cin >> x;
      edge[j][i - 1] = {x, i};
      g[j][i].push_back(x);
      g[j][x].push_back(i);
    }
  }
  for (int j = 0; j < 2; j++) {
    cnt = 0;
    dfs(j, 1, 1);
  }
  for (int j = 0; j < 2; j++) {
    for (int i = 1; i < n; i++) {
      if (f[j][edge[j][i].first] > f[j][edge[j][i].second])
        swap(edge[j][i].first, edge[j][i].second);
    }
  }
  for (int j = 0; j < 2; j++) {
    for (int i = 1; i < n; i++) {
      int par = edge[1 - j][i].first, u = edge[1 - j][i].second;
      if (st[j][par] < st[j][u]) {
        update(0, j, 1, 1, n, st[j][u], st[j][u], {0, {st[j][par], i}});
        update(1, j, 1, 1, n, st[j][par], st[j][par], {0, {st[j][u], i}});
      } else {
        update(0, j, 1, 1, n, st[j][par], st[j][par], {0, {st[j][u], i}});
        update(1, j, 1, 1, n, st[j][u], st[j][u], {0, {st[j][par], i}});
      }
    }
  }
  cin >> idx;
  Edge.push_back({idx, 0});
  inAns[0][idx] = 1;
  while (Edge.size() > 0) {
    int type = Edge[0].second;
    print(type);
    for (int i = 0; i < Edge.size(); i++) cout << Edge[i].first << " ";
    cout << "\n";
    for (int i = 0; i < Edge.size(); i++) {
      idx = Edge[i].first;
      int par = edge[type][idx].first, u = edge[type][idx].second;
      while (1) {
        pair<int, int> ans = get(0, type, 1, 1, n, st[type][u], en[type][u]);
        if (ans.first > en[type][u] ||
            (st[type][u] <= ans.first && ans.first <= en[type][u]))
          break;
        else {
          if (!inAns[1 - type][ans.second])
            Temp.push_back({ans.second, 1 - type});
          inAns[1 - type][ans.second] = 1;
          if (st[type][edge[1 - type][ans.second].second] < st[type][u]) {
            update(0, type, 1, 1, n, st[type][edge[1 - type][ans.second].first],
                   st[type][edge[1 - type][ans.second].first], {inf, ans});
            update(1, type, 1, 1, n,
                   st[type][edge[1 - type][ans.second].second],
                   st[type][edge[1 - type][ans.second].second], {inf, ans});
          } else if (st[type][edge[1 - type][ans.second].first] < st[type][u]) {
            update(0, type, 1, 1, n,
                   st[type][edge[1 - type][ans.second].second],
                   st[type][edge[1 - type][ans.second].second], {inf, ans});
            update(1, type, 1, 1, n, st[type][edge[1 - type][ans.second].first],
                   st[type][edge[1 - type][ans.second].first], {inf, ans});
          }
        }
      }
      while (1) {
        pair<int, int> ans = get(1, type, 1, 1, n, st[type][u], en[type][u]);
        if (ans.first < st[type][u] ||
            (st[type][u] <= ans.first && ans.first <= en[type][u]))
          break;
        else {
          if (!inAns[1 - type][ans.second])
            Temp.push_back({ans.second, 1 - type});
          inAns[1 - type][ans.second] = 1;
          if (st[type][edge[1 - type][ans.second].second] > en[type][u]) {
            update(1, type, 1, 1, n, st[type][edge[1 - type][ans.second].first],
                   st[type][edge[1 - type][ans.second].first], {inf, ans});
            update(0, type, 1, 1, n,
                   st[type][edge[1 - type][ans.second].second],
                   st[type][edge[1 - type][ans.second].second], {inf, ans});
          } else if (st[type][edge[1 - type][ans.second].first] > en[type][u]) {
            update(1, type, 1, 1, n,
                   st[type][edge[1 - type][ans.second].second],
                   st[type][edge[1 - type][ans.second].second], {inf, ans});
            update(0, type, 1, 1, n, st[type][edge[1 - type][ans.second].first],
                   st[type][edge[1 - type][ans.second].first], {inf, ans});
          }
        }
      }
    }
    sort(Temp.begin(), Temp.end());
    Edge = Temp;
    Temp.clear();
  }
}
