#include <stdio>
#include <vector>
#include <list>
using namespace std;


//Реализовать кучу на массиве с операциями Add,Delete,SiftDown, удаление по указателю
//Для списков аналогично удалаение по указателю и вставка перед элементом к которому обратились по указателю
//Как получать адрес новго созданного отрезка? После создания или обяз после добавления в список?

// а<b
bool operator<(const heap_element& a, const heap_element& b)
{
    int len_a = a.r-a.l;
    int len_b = b.r-b.l;

    if ( (a.r-a.l < b.r-b.l) )
        return true;
    if ( (a.r-a.l == b.r-b.l) & (a.l > b.l))
        return true;

    return false;
}

struct heap_elements {
    int l;
    int r;
    int position;
    list_segments *to_list; //Указатель на себя в списке отрезков.
};

struct list_segments {  //Структура отрезка - элемента списка отрезок
    int l;
    int r;
    int status;         // Но лучше просто считать это элементов класса и делать del по указателю
    int position; //Найдя по указателю отерзок поймём какой он в списке и вызовем del(pos)
    struct list_segments *next;
    struct list_segments *prev;
    heap_elements *to_heap; //Указатель на себя в куче (элемент структуры heap_elements)

}

int main()
{
    //Массив указателей на отрезки (list_segments)
    vector<*list_segments> requests;

    Heap heap;

    int N,M,K;


    cin>> << N;
    // Узнали N, можно добавить весь массив в структуры данных

    //Создание вершины и добавление в кучу
    heap_elements vertex;
    vertex.l = 1;
    vertex.r = N;
    vertex.to_list = NULL;
    //adress = &vertex;  //?????????????
    heap.add(vertex);

    //Cоздание списка отрезков
    list_segments segment; //Создаем отрезок-структуру, заполняем
    segment.l = 1;
    segment.r = N;
    segment.status = 1;
    segment.position = 0; //Не надо, можно просто удалять
    segment.next = NULL;
    segment.prev = NULL;
    segment.to_heap  = &heap[0]; //?????????????

    list <list_segments> segments; //Создаём пустой двусязный список
    segments.push_back(segment);
    vertex.to_list = &segments.back //Записываем в вершину запись её копии в списке отрезков (можно ли это сделать просто &segment?)

    cin >> M;
    for (int i=0; i < M; ++i) { //Обрабатываем запросы

        cin >> K;

        if (K > 0) {
            if (!heap.is_empty() & (heap[0].r-heap[0].l+1) >= K) {

                //Меняем значение у структуры в вершине на [l+K,r]
                heap[0].l = l+K;

                //о указателю из структуры в вершине находим отрезок [l,r] списка отрезков, меняем его на [l+K,r]
                heap[0].to_list->l = l+K;

                //Создаём перед отрезком новый элемент списка [l,l+K−1], status=0, указатель пустой.
                //Написать класс  и просто делать init
                segment.l = l;
                segment.r = l+K-1;
                segment.status = 0;
                segment.position = heap.to_list->position - 1; //Не надо
                segments.to_heap = NULL;
                segments.push(segment, heap[0].to_list); //Перед  heap[0].to_list

                //Делаем просеивание вершины
                SiftDown(0);

                //В массиве запросов на i−1 индексе записываем в указатель адрес созданного элемента списка.
                requests[i]  = &segments[segment.position];

                cout << l;
            }
            else {
                requests[i] = NULL;
                cout << -1 << endl;
            }
        }

        else {
            q = abs(K)-1;
            if (requests[q] != NULL) {
                //Получаем по указателю из (q−1)-го элемента массива запросов адрес занятого отрезка в списке.
                //Меняем status с 0 на 1.
                requests[q]->status = 0;


                //Смотрим на отрезки слева и справа от освобожденного отрезка. Если отрезки идут подряд (один или оба),
                //то по указателям находим их в куче (один или оба) и удаляем, затем объединяем их в один.
                bool flag_l = false ,flag_r = false;
                if (requests[q]->prev->r == requests[q].l-1) {
                    requests[q].l = requests[q]->prev->l //Слили с левым

                    heap.del(requests[q]->prev->to_heap) // удаляем левый в куче
                    segments.del(requests[q]->prev) // удаляем левый в списке отрезоков
                }
                if (requests[q]->next->l-1 == requests[q].r) {
                    requests[q].r = requests[q]->next->r //Слили с правым

                    heap.del(requests[q]->next->to_heap) // удаляем левый в куче
                    segments.del(requests[q]->prev) // удаляем левый в списке отрезоков
                }

                //Создаю новый элемент структуры для добавления в кучу.
                vertex = heap_elements(requests[q].l,requests[q].r,*requests[q])

                //Указатель нового отрезка в списке приравниваю к адресу созданного элемента структуры.
                requests[q].to_heap = &vertex;

                //Добавляю в кучу полученный отрезок с помощью Add.
                heap.Add(vertex);

            }

            else {
                requests[i] = NULL;
            }
        }

    }











    return 0;
}