#include <bits/stdc++.h>
using namespace std;
struct Edge {
  int u, v, id;
};
struct Vertice {
  set<int> outs;
};
int n, m;
Edge edges[212345];
Vertice vertices[2 * 212345];
set<int>::iterator its[2 * 212345];
bool used_edge[212345];
void init() {
  for (int i = 0; i < n; i++) {
    its[i] = vertices[i].outs.begin();
  }
}
int find_src() {
  int src = 0;
  for (int i = 0; i < n; i++) {
    if (vertices[i].outs.size() & 1) {
      src = i;
      break;
    }
    if (vertices[i].outs.size()) src = i;
  }
  return src;
}
bool check_condition() {
  int c = 0;
  for (int i = 0; i < n; ++i) c += (vertices[i].outs.size() & 1);
  return (c == 2 || c == 0);
}
vector<int> euler_tour(int n_edges, int src = -1) {
  if (!check_condition()) return {};
  if (src == -1) {
    src = find_src();
  }
  vector<int> ret_edges;
  vector<pair<int, int> > s = {{src, -1}};
  while (!s.empty()) {
    int x = s.back().first;
    int e = s.back().second;
    auto &it = its[x], end = vertices[x].outs.end();
    while (it != end && used_edge[*it]) ++it;
    if (it == end) {
      ret_edges.push_back(e);
      s.pop_back();
    } else {
      auto edge = edges[*it];
      int v = edge.u == x ? edge.v : edge.u;
      s.push_back({v, *it});
      used_edge[*it] = true;
    }
  }
  reverse(ret_edges.begin(), ret_edges.end());
  return ret_edges;
}
int main() {
  scanf("%d", &m);
  n = 2 * 212345;
  for (int i = 0; i < m; i++) {
    int x, y;
    scanf("%d%d", &x, &y);
    y += 212345;
    edges[i] = {x, y, i};
    vertices[x].outs.insert(i);
    vertices[y].outs.insert(i);
  }
  queue<int> odds;
  for (int i = 0; i < 2 * 212345; i++) {
    if (!vertices[i].outs.empty()) odds.push(i);
  }
  stack<pair<int, int> > removed_edges;
  while (!odds.empty()) {
    int u = odds.front();
    odds.pop();
    if ((int)vertices[u].outs.size() & 1) {
      int e = *vertices[u].outs.begin();
      removed_edges.push({e, u});
      int x = edges[e].u;
      int y = edges[e].v;
      vertices[x].outs.erase(e);
      vertices[y].outs.erase(e);
      if ((int)vertices[y].outs.size() & 1) {
        odds.push(y);
      }
      if ((int)vertices[x].outs.size() & 1) {
        odds.push(x);
      }
    }
  }
  vector<char> color(m);
  vector<int> balance(2 * 212345);
  init();
  for (int i = 0; i < 2 * 212345; i++) {
    if (!vertices[i].outs.empty() && !used_edge[*vertices[i].outs.begin()]) {
      auto res = euler_tour(i);
      char c = 'r';
      for (int j : res) {
        ;
        if (j == -1) continue;
        color[j] = c;
        if (c == 'r') {
          balance[edges[j].u]++;
          balance[edges[j].v]++;
          c = 'b';
        } else {
          balance[edges[j].u]--;
          balance[edges[j].v]--;
          c = 'r';
        }
      }
    }
  }
  while (!removed_edges.empty()) {
    int e, u, v;
    tie(e, u) = removed_edges.top();
    v = edges[e].u == u ? edges[e].v : edges[e].u;
    removed_edges.pop();
    if (balance[v] > 0) {
      color[e] = 'b';
      balance[u]--;
      balance[v]--;
    } else {
      color[e] = 'r';
      balance[u]++;
      balance[v]++;
    }
  }
  for (char c : color) printf("%c", c);
  printf("\n");
}
