#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 2;
int n, cnt, now, nxt;
vector<int> ans[2];
class segTree {
  class node {
   public:
    node(int l, int r) : l(l), r(r) { del = 0, son[0] = son[1] = nullptr; }
    friend class segTree;

   private:
    int l, r, del;
    node* son[2];
    vector<int> num;
  };

 public:
  segTree() {
    memset(del, 0, sizeof(del)), build(root = new node(1, maxn - 2));
  }
  void insert(int l, int r, int x) { return insert(root, l, r, x); }
  int remove(int x) { return remove(root, x); }
  int del[maxn];

 private:
  void build(node* nd) {
    if (nd->l == nd->r) return;
    int m = (nd->l + nd->r) >> 1;
    return build(nd->son[0] = new node(nd->l, m)),
           build(nd->son[1] = new node(m + 1, nd->r));
  }
  void insert(node* nd, int l, int r, int x) {
    if (l <= nd->l && nd->r <= r)
      return nd->num.emplace_back(x);
    else if (r <= nd->son[0]->r)
      return insert(nd->son[0], l, r, x);
    else if (l >= nd->son[1]->l)
      return insert(nd->son[1], l, r, x);
    else
      return insert(nd->son[0], l, r, x), insert(nd->son[1], l, r, x);
  }
  int remove(node* nd, int x) {
    int cnt = 0;
    if (!nd->del) {
      for (int n : nd->num)
        if (!del[n]) del[n] = ++cnt, ans[nxt].emplace_back(n);
      nd->del = cnt;
    }
    if (nd->l == nd->r)
      return cnt;
    else if (x <= nd->son[0]->r)
      return cnt + remove(nd->son[0], x);
    else if (x >= nd->son[1]->l)
      return cnt + remove(nd->son[1], x);
    else
      return 0;
  }
  node* root;
};
struct Tree {
  segTree tree;
  vector<int> nxt[maxn];
  int n, fa[maxn], son[maxn], dep[maxn], siz[maxn], dfn[maxn], top[maxn];
  void dfs1(int u) {
    siz[u] = 1;
    for (int v : nxt[u])
      dep[v] = dep[u] + 1, dfs1(v), siz[u] += siz[v],
      son[u] = (siz[v] > siz[son[u]] ? v : son[u]);
    return;
  }
  void dfs2(int u) {
    dfn[u] = ++n, top[u] = (son[fa[u]] == u ? top[fa[u]] : u);
    if (son[u]) dfs2(son[u]);
    for (int v : nxt[u])
      if (v != son[u]) dfs2(v);
    return;
  }
  inline void insert(int l, int r, int x) {
    while (top[l] != top[r])
      if (dep[top[l]] > dep[top[r]])
        tree.insert(dfn[top[l]], dfn[l], x), l = fa[top[l]];
      else
        tree.insert(dfn[top[r]], dfn[r], x), r = fa[top[r]];
    if (l != r)
      if (dep[l] > dep[r])
        tree.insert(dfn[r] + 1, dfn[l], x);
      else
        tree.insert(dfn[l] + 1, dfn[r], x);
    return;
  }
  inline int remove(int x) { return tree.remove(dfn[x]); }
} tree[2];
int main() {
  cin.tie(0), cout.tie(0), ios::sync_with_stdio(0), cin >> n,
      tree[0].n = tree[1].n = 0, now = 1;
  for (int i = 2; i <= n; i++)
    cin >> tree[0].fa[i], tree[0].nxt[tree[0].fa[i]].emplace_back(i);
  for (int i = 2; i <= n; i++)
    cin >> tree[1].fa[i], tree[1].nxt[tree[1].fa[i]].emplace_back(i);
  tree[0].dfs1(1), tree[0].dfs2(1), tree[1].dfs1(1), tree[1].dfs2(1);
  for (int i = 2; i <= n; i++)
    tree[0].insert(i, tree[1].fa[i], i), tree[1].insert(i, tree[0].fa[i], i);
  cin >> n, tree[now].tree.del[n + 1] = 1, ans[nxt].emplace_back(n + 1);
  do {
    cnt = 0, now ^= 1, nxt ^= 1, ans[nxt].clear(),
    cout << (now ? "Red" : "Blue") << endl,
    sort(ans[now].begin(), ans[now].end());
    for (int i : ans[now]) cout << i - 1 << ' ';
    cout << endl;
    for (int i : ans[now]) cnt += tree[now].remove(i);
  } while (cnt);
  return 0;
}
