#include <iostream>
#include <deque>
using namespace std;

int main()
{
    Heap heap1;
    Heap heap2;
    char c;

    int count = 0;
    ID1 = -1;
    ID2 = -1;
    deque<int> deq1;
    deque<int> deq2;
    int ID1toID2[N];
    int ID2toID1[N];

    int N, M, K, ID;
    N = 5;
    M = 5;
    int heapIdxToID[N];

    int a[N] = {1,2,3,4,5};

    for (int = 0; i < M; ++i)
    {
        cin >> c;
        if (c == 'R')
        {
            count++;
            R++;

            if (count < K)  //Не хватает - просто добавляем в 1 кучу
            {
                ID1++;
                heap1.add(a[R], ID1); //ID1 - номер добавления элемента в 1 кучу
                deq1.push_back(ID1);
                cout << "-1" << endl;
            }
            if (count == K) //Только что набралось нужное число, просто добавляем к-ый и выводим
            {
                ID1++;
                heap1.add(a[R], ID1);
                deq1.push_back(ID1);
                cout << heap1.get_root(); << endl;
            }
            if (count > K) //Появились лишние - их во вторую кучу (если больше корня, иначе в 1 а корень во вторую)
            {

                if (a[R] > heap1.get_root()) //Если больше корня то во вторую кучу просто
                {
                    ID2++;
                    heap2.add(a[R], ID2);
                    deq2.push_back(ID2);
                    cout << heap1.get_root() << endl;
                }

                else //Иначе корень стал уже к+1 и его во вторую надо
                            //!!!!!(тут все ломается по ID , вершина может уже быть в другой куче, тогда как ее найти про сдвиге L?)
                {

                    root1_ID = heap1IdxToID[0];
                    heap1.del(root1_ID); //Удаляю вершину (Раз его удаляю, то в очереди ID его тоже надо удалить как? - ID совпдают)
                    //Вместо удаления запишу -ID2 добавления во вторую кучу

                    ID1++;
                    heap1.add(a[R], ID1); //Добавляю новый элемент в 1 куче
                    deq1.push_back(ID1)

                    ID2++;
                    root1 = heap1.get_root();
                    heap2.add(root1, ID2);  //Добавляю вершину 1 кучи во вторую, т.к она уже >k-ая статистика
                    deq2.push_back(ID2);
                    deq1[root1ID] = -ID2; //Вместо удаления запишу -ID2 добавления во вторую кучу чтобы потом понять где искать
                    ID1toID2[root1ID] = ID2;
                    ID2toID1[ID2] = root1ID;
                }
            }
        }
        else
        {
            L--;
            count--;
            if (count < K) //Стало недостаточно, удаляем первый добавленный в 1 кучу
            {
                ID = deq1[0]; //В deq1[0] лежит номер первого добавленного (крч лежит ID a[L])
                if (ID < 0) { //Значит элемент лежит во 2 куче и там его надо искать
                    deq1.pop_front();
                    //deq2.pop_front();
                    heap2.del(-ID);
                    cout << "-1" << endl;
                }
                else {
                    deq1.pop_front();
                    heap1.del(ID);
                    cout << "-1" << endl;
                }
            }
            if (count >= K) //В 1 куче к-1, во 2 от 1. Надо удалить первый в 1 куче, перебросить из 2 кучи , удалить его и вывести
            {
                ID = deq1[0];

                if (ID < 0) { //Значит элемент лежит во 2 куче и там его надо искать
                    deq1.pop_front();
                    //deq2.pop_front();
                    heap2.del(-ID);
                }
                else
                {
                    deq1.pop_front();
                    heap1.del(ID);   //удаляю из первой кучи первый туда добавленный
                }

                ID1++;
                heap1.add(heap2.get_root(), ID1); // добавляю из 2 кучи в первую (по идее вседа в корень т.к. он больше остальных)
                //deq1.push_back(ID1);  //!!!!А не нарушиться ли от такого добавления порядок в массиве? надо же самый левый удалять
                                            //Нарушиться. Но просто этого не надо делать только при R++ обновлять
                ID_top2 = heap2IdxToID[0]; //узнаю какой айди у вершины второй кучи
                heap2.del(ID_top2); //удаляю вершину у 2 кучи

                //Теперь эту вершину надо искать в 1 куче (если после L++ надо ее удалить). Но где она лежит в deq1?
                deq1[ID2toID1[ID_top2]] = ID2toID1[ID_top2];
                cout << heap1.get_root() << endl;
                }
            }

        }
    }
    return 0;
}