#include <bits/stdc++.h>
using namespace std;
#define RED 0
#define BLACK 1

//定义红黑树结点
struct Node
{
    char color;   //颜色
    int key;      //值
    Node *lchild; //左孩子
    Node *rchild; //右孩子
    Node *parent; //父结点
};

class RBtree
{
public:
    //新建一个结点
    Node *creat_root(int key, Node *parent, Node *lchild, Node *rchild)
    {
        Node *p;
        p = new Node();
        p->key = key;
        p->lchild = lchild;
        p->rchild = rchild;
        p->color = BLACK;
        return p;
    }

    //左旋——将该结点变成其右孩子的左孩子
    void rbtree_left_rotate(Node *&root, Node *x)
    {
        Node *y = x->rchild; //设置x的右结点等于y

        //首先，先找到y的左孩子,它最终被x收养为右孩子
        x->rchild = y->lchild;
        if (y->lchild != NULL)
            y->lchild->parent = x;

        //将x的父亲设为y的父亲
        y->parent = x->parent;

        if (x->parent == NULL) //当x为根结点的时候
        {
            root = y; //将y设为根结点
        }
        else //当x不是根节点的时候
        {
            if (x->parent->lchild == x)
            {
                x->parent->lchild = y; // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
            }
            else
            {
                x->parent->rchild = y; // 如果 x是它父节点的左孩子，则将y设为“x的父节点的左孩子”
            }
        }
        y->lchild = x; //x就位
        x->parent = y;
        //printf("（对关键字%d进行左旋）",x->key);
    }

    //右旋
    void rbtree_right_rotate(Node *&root, Node *y)
    {
        Node *x = y->lchild;

        y->lchild = x->rchild;
        //找到x的右孩子，它最终被y收养为左孩子
        if (x->rchild != NULL)
        {
            x->rchild->parent = y;
        }
        x->parent = y->parent;
        //此时x的右孩子是空的，y来当x的右孩子
        if (y->parent == NULL) //如果y为根结点
        {
            root = x; //将x设为根节点
        }
        else
        {
            if (y->parent->rchild == y) //要确定x是做的左孩子还是右孩子
            {
                y->parent->rchild = x;
            }
            else
            {
                y->parent->lchild = x;
            }
        }
        x->rchild = y; //y就位
        y->parent = x;
    }

    //插入修正 —— 先向该树直接插入一个结点，设置为红色，为了不影响性质4，再进行调整
    void rbtree_insert_fixup(Node *&root, Node *node)
    {
        Node *parent, *gparent;
        // 若父节点存在，并且父节点的颜色是红色
        while ((parent = node->parent) && (parent->color == RED))
        {
            gparent = parent->parent;

            //若“父节点”是“祖父节点的左孩子”
            if (parent == gparent->lchild)
            {
                // Case 1条件：叔叔节点是红色
                {
                    Node *uncle = gparent->rchild;
                    if (uncle && uncle->color == RED)
                    { //父、叔变黑，爷变红,对爷进行判断
                        uncle->color = BLACK;
                        parent->color = BLACK;
                        gparent->color = RED;
                        node = gparent;
                        continue;
                    }
                }

                // Case 2条件：叔叔是黑色，且当前节点是右孩子
                if (parent->rchild == node)
                {
                    Node *tmp;
                    rbtree_left_rotate(root, parent); //父左旋
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // Case 3条件：叔叔是黑色，且当前节点是左孩子。
                parent->color = BLACK;
                gparent->color = RED;
                rbtree_right_rotate(root, gparent);
            }
            else //若“z的父节点”是“z的祖父节点的右孩子”
            {
                // Case 1条件：叔叔节点是红色
                {
                    Node *uncle = gparent->lchild;
                    if (uncle && (uncle->color == RED))
                    {
                        uncle->color = BLACK;
                        parent->color = BLACK;
                        gparent->color = RED;
                        node = gparent;
                        continue;
                    }
                }

                // Case 2条件：叔叔是黑色，且当前节点是左孩子
                if (parent->lchild == node)
                {
                    Node *tmp;
                    rbtree_right_rotate(root, parent);
                    tmp = parent;
                    parent = node;
                    node = tmp;
                }

                // Case 3条件：叔叔是黑色，且当前节点是右孩子。
                parent->color = BLACK;
                gparent->color = RED;
                rbtree_left_rotate(root, gparent);
            }
        }

        // 将根节点设为黑色
        root->color = BLACK;
    }

    //插入
    void rbtree_insert(Node *&root, Node *node)
    {
        Node *y = NULL;
        Node *x = root;

        while (x != NULL) //x为叶子结点跳出循环
        {
            y = x;
            if (x->key > node->key)
            {
                x = x->lchild;
            }
            else
            {
                x = x->rchild;
            }
        }
        node->parent = y;

        if (y != NULL)
        {
            if (node->key < y->key)
            {
                y->lchild = node;
            }
            else
            {
                y->rchild = node;
            }
        }
        else
        {
            root = node; //若y为NULL，说明树为空，则将node设为根节点
        }

        node->color = RED; //将颜色设为红色

        //插入修正
        rbtree_insert_fixup(root, node);
    }

    int insert_rbtree(Node *&root, int key)
    {
        Node *node; //新建一个结点
        node = creat_root(key, NULL, NULL, NULL);
        if (node == NULL)
            return -1;
        else
            rbtree_insert(root, node);
        return 0;
    }

    //中序遍历"红黑树"
    void inorder(Node *root)
    {
        if (root != NULL)
        {
            inorder(root->lchild);
            //cout << root->key<<" ";
            if (root->color == 0)
            {
                cout << "R";
            }
            else
            {
                cout << "B";
            }
            inorder(root->rchild);
        }
    }
};

int main()
{
    int N;
    cin >> N;
    int a[N];
    RBtree mytree;
    //下面开始创建红黑树
    Node *root = new Node();
    cin >> a[0];
    root = mytree.creat_root(a[0], NULL, NULL, NULL);
    //然后插入
    for (int i = 1; i < N; i++)
    {
        cin >> a[i];
        mytree.insert_rbtree(root, a[i]);
    }
    mytree.inorder(root);
    return 0;
}