import java.io.*;
import java.util.*;

public class TaskD {
    private final InputReader reader;
    private final OutputWriter writer;

    public TaskD(InputReader reader, OutputWriter writer) {
        this.reader = reader;
        this.writer = writer;
    }

    public static void main(String[] args) {
        InputReader reader = new InputReader(System.in);
        OutputWriter writer = new OutputWriter(System.out);
        new TaskD(reader, writer).run();
        writer.writer.flush();
    }

    int[] col;
    List<Integer>[] E;

    int[] A, B;
    int to(int e, int x) {
        return A[e] ^ B[e] ^ x;
    }

    int[] ept;
    void DFS(int x, int f) {
        while (ept[x] != E[x].size() && col[E[x].get(ept[x])] != -1)
            ept[x]++;
        if (ept[x] == E[x].size())
            return;
        int e = E[x].get(ept[x]++);
        col[e] = f;
        DFS(to(e, x), 1 - f);
    }

    public void run() {
        int n = reader.nextInt();
        final int N = 200500;
        E = new List[3 * N];
        for (int i = 0; i < 3 * N; i++)
            E[i] = new ArrayList<Integer>();
        int[] X = new int[N];
        int[] Y = new int[N];
        A = new int[3 * N];
        B = new int[3 * N];
        ept = new int[3 * N];
        col = new int[3 * N];
        Arrays.fill(col, -1);
        for (int i = 0; i < n; i++) {
            X[i] = reader.nextInt() - 1;
            Y[i] = reader.nextInt() - 1;
            A[i] = X[i];
            B[i] = Y[i] + N;
            E[X[i]].add(i);
            E[Y[i] + N].add(i);
        }
        int pt = 2 * N;
        int ppt = N;
        int parity = 0;

        boolean was = false;
        for (int i = 0; i < 2 * N; i++)
            if (E[i].size() % 2 == 1) {
                if (parity == 1 && ppt > N && A[ppt - 1] < N && i >= N && !was) {
                    B[ppt - 1] = i;
                    E[i].add(ppt - 1);
                    parity = 0;
                    was = true;
                } else {
                    A[ppt] = i;
                    B[ppt] = pt;
                    E[A[ppt]].add(ppt);
                    E[B[ppt]].add(ppt);
                    ppt++;
                    if (parity == 0)
                        parity = 1;
                    else {
                        pt++;
                        parity = 0;
                    }
                }
            }
        if (parity == 1)
            throw new AssertionError();
        for (int i = 0; i < 2 * N; i++) {
            DFS(i, 0);
        }
        char[] ans = new char[n];
        for (int i = 0; i < n; i++) {
            if (col[i] == -1)
                throw new AssertionError();
            ans[i] = col[i] == 1 ? 'r' : 'b';
        }
        writer.printf("%s\n", String.valueOf(ans));
    }


    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}