#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int totb = 0, totr = 0, totx = 0, deep;
int n;
struct data {
  int next, num;
} edgeb[400001], edger[400001];
struct data2 {
  int x;
  bool judge;
} ans[200001];
struct seg {
  int l, r, va;
} tr[1600001], tb[1600001];
int headb[200001], headr[200001];
int wb[200001], wr[200001], vr[200001], vb[200001], db[200001], dr[200001];
int fab[200001][19], far[200001][19], lb[200001], rb[200001], lr[200001],
    rr[200001];
int eb[200001], er[200001], vab[400001], var[400001], locb[400001],
    locr[400001], px;
bool visb[200001], visr[200001];
queue<data2> q;
bool cmp(data2 p, data2 q) { return p.x < q.x; }
void add1(int u, int v) {
  edgeb[++totb].next = headb[u];
  edgeb[totb].num = v;
  headb[u] = totb;
}
void add2(int u, int v) {
  edger[++totr].next = headr[u];
  edger[totr].num = v;
  headr[u] = totr;
}
void dfsb1(int x) {
  wb[x] = vb[x];
  db[x] = deep;
  lb[x] = totx + 1;
  totx += wb[x];
  for (int i = headb[x]; i != -1; i = edgeb[i].next) {
    int kx = edgeb[i].num;
    if (!db[kx]) {
      deep++;
      fab[kx][0] = x;
      dfsb1(kx);
      deep--;
      wb[x] += wb[kx];
    }
  }
  rb[x] = totx;
}
void dfsr1(int x) {
  wr[x] = vr[x];
  dr[x] = deep;
  lr[x] = totx + 1;
  totx += wr[x];
  for (int i = headr[x]; i != -1; i = edger[i].next) {
    int kx = edger[i].num;
    if (!dr[kx]) {
      deep++;
      far[kx][0] = x;
      dfsr1(kx);
      deep--;
      wr[x] += wr[kx];
    }
  }
  rr[x] = totx;
}
void build(int i, int l, int r) {
  tr[i].l = tb[i].l = l;
  tr[i].r = tb[i].r = r;
  if (l == r) {
    tb[i].va = vab[l];
    tr[i].va = var[l];
    if (locr[l] == px) tr[i].va = INF;
    return;
  }
  int mid = (l + r) / 2;
  build(i * 2, l, mid);
  build(i * 2 + 1, mid + 1, r);
  tr[i].va = min(tr[i * 2].va, tr[i * 2 + 1].va);
  tb[i].va = min(tb[i * 2].va, tb[i * 2 + 1].va);
}
void deleb(int i, int l, int r, int va) {
  int nowl = tb[i].l, nowr = tb[i].r;
  if (nowl > r || nowr < l) return;
  if (tb[i].va > va) return;
  if (nowl == nowr) {
    tb[i].va = INF;
    if (visb[locb[nowl]]) return;
    tb[i].va = INF;
    data2 now;
    now.x = locb[nowl];
    now.judge = 1;
    q.push(now);
    visb[now.x] = 1;
    return;
  }
  deleb(i * 2, l, r, va);
  deleb(i * 2 + 1, l, r, va);
  tb[i].va = min(tb[i * 2].va, tb[i * 2 + 1].va);
}
void deler(int i, int l, int r, int va) {
  int nowl = tr[i].l, nowr = tr[i].r;
  if (nowl > r || nowr < l) return;
  if (tr[i].va > va) return;
  if (nowl == nowr) {
    tr[i].va = INF;
    if (visr[locr[nowl]]) return;
    data2 now;
    now.x = locr[nowl];
    now.judge = 0;
    q.push(now);
    visr[now.x] = 1;
    return;
  }
  deler(i * 2, l, r, va);
  deler(i * 2 + 1, l, r, va);
  tr[i].va = min(tr[i * 2].va, tr[i * 2 + 1].va);
}
void prelca() {
  fab[1][0] = far[1][0] = 1;
  for (int j = 1; j <= 18; j++)
    for (int i = 1; i <= n; i++) {
      far[i][j] = far[far[i][j - 1]][j - 1];
      fab[i][j] = fab[fab[i][j - 1]][j - 1];
    }
}
int lcab(int u, int v) {
  while (db[u] > db[v]) {
    int kx = log2(db[u] - db[v]);
    u = fab[u][kx];
  }
  while (db[u] < db[v]) {
    int kx = log2(db[v] - db[u]);
    v = fab[v][kx];
  }
  if (u == v) return u;
  int kg = log2(db[u]);
  for (int i = kg; i >= 0; i--) {
    if (fab[u][i] == fab[v][i]) continue;
    u = fab[u][i];
    v = fab[v][i];
  }
  return fab[u][0];
}
int lcar(int u, int v) {
  while (dr[u] > dr[v]) {
    int kx = log2(dr[u] - dr[v]);
    u = far[u][kx];
  }
  while (dr[u] < dr[v]) {
    int kx = log2(dr[v] - dr[u]);
    v = far[v][kx];
  }
  if (u == v) return u;
  int kg = log2(dr[u]);
  for (int i = kg; i >= 0; i--) {
    if (far[u][i] == far[v][i]) continue;
    u = far[u][i];
    v = far[v][i];
  }
  return far[u][0];
}
void prep() {
  memset(headr, -1, sizeof(headr));
  memset(headb, -1, sizeof(headb));
  scanf("%d", &n);
  for (int i = 2; i <= n; i++) {
    scanf("%d", &eb[i]);
    add1(i, eb[i]);
    add1(eb[i], i);
  }
  for (int i = 2; i <= n; i++) {
    scanf("%d", &er[i]);
    add2(i, er[i]);
    add2(er[i], i);
  }
  for (int i = 2; i <= n; i++) {
    vr[i]++;
    vr[eb[i]]++;
    vb[i]++;
    vb[er[i]]++;
  }
  deep = 1;
  totx = 0;
  dfsb1(1);
  deep = 1;
  totx = 0;
  dfsr1(1);
  memset(vr, 0, sizeof(vr));
  memset(vb, 0, sizeof(vb));
  prelca();
  for (int i = 2; i <= n; i++) {
    vr[i]++;
    vr[eb[i]]++;
    var[vr[i] + lr[i] - 1] = var[vr[eb[i]] + lr[eb[i]] - 1] =
        dr[lcar(i, eb[i])];
    locr[vr[i] + lr[i] - 1] = locr[vr[eb[i]] + lr[eb[i]] - 1] = i - 1;
    vb[i]++;
    vb[er[i]]++;
    vab[vb[i] + lb[i] - 1] = vab[vb[er[i]] + lb[er[i]] - 1] =
        db[lcab(i, er[i])];
    locb[vb[i] + lb[i] - 1] = locb[vb[er[i]] + lb[er[i]] - 1] = i - 1;
  }
  scanf("%d", &px);
  build(1, 1, 2 * n - 2);
}
int getp(data2 x) {
  int i = x.x;
  if (x.judge == 0) {
    if (db[i + 1] < db[eb[i + 1]]) return eb[i + 1];
    return i + 1;
  }
  if (dr[i + 1] < dr[er[i + 1]]) return er[i + 1];
  return i + 1;
}
void work() {
  data2 gx;
  gx.judge = 0;
  gx.x = px;
  q.push(gx);
  visr[px] = 1;
  int headpx = 0;
  while (!q.empty()) {
    data2 k = q.front();
    ans[++headpx] = k;
    q.pop();
    int point = getp(k);
    if (k.judge == 0)
      deleb(1, lb[point], rb[point], db[point] - 1);
    else
      deler(1, lr[point], rr[point], dr[point] - 1);
  }
  printf("Blue\n%d", ans[1].x);
  for (int i = 2; i <= headpx; i++) {
    if (ans[i].judge != ans[i - 1].judge) {
      int nowj = i;
      while (nowj <= headpx && ans[nowj].judge == ans[i].judge) nowj++;
      sort(ans + i, ans + nowj, cmp);
      if (ans[i].judge == 0)
        printf("\nBlue\n");
      else
        printf("\nRed\n");
    }
    printf("%d ", ans[i].x);
  }
}
int main() {
  prep();
  work();
  return 0;
}
