#include <iostream>
#include <string>
#include <vector>
using namespace std;

const int MAX = 2e5;

struct vertex
{
    int res;
    int left;
    int right;
};

class Segment_Tree
{
    struct vertex* tree;
    int tree_size;
    int count_numbers;
    std::vector<int> numbers;

public:
    void build_tree(const std::vector<int>& numbers, int v, int tl, int tr);
    int to_deg_of_two(std::vector<int>& numbers, int count_numbers);
    void Initialize(int count_numbers);
    void set(int k, int x);
    int get_min(int node, int a, int b);
    int find_spot(char* start_number);
    int free_up(char* number);
};

void Segment_Tree::build_tree(const std::vector<int>& numbers, int v, int tl, int tr)
{

    if (tr - tl == 1)
    {
        tree[v].res = numbers[tl];
        tree[v].left = tl;
        tree[v].right = tr;
    }
    else
    {
        int tm = (tl + tr) / 2;
        build_tree(numbers, v * 2 + 1, tl, tm);
        build_tree(numbers, v * 2 + 2, tm, tr);
        tree[v].left = tl;
        tree[v].right = tr;

        if (tree[v * 2 + 1].res < tree[v * 2 + 2].res)
            tree[v].res = tree[v * 2 + 1].res;
        else
            tree[v].res = tree[v * 2 + 2].res;
    }
}

int Segment_Tree::to_deg_of_two(std::vector<int>& numbers, int count_numbers)
{

    int p = 1;
    while (count_numbers > p)
        p *= 2;

    for (int i = 0; i < p - count_numbers; ++i)
        numbers.push_back(MAX);

    return 2 * p;
}

void Segment_Tree::Initialize(int count_numbers)
{

    this->count_numbers = count_numbers;
    for (int i = 1; i <= count_numbers; ++i)
        numbers.push_back(i);

    this->tree_size = to_deg_of_two(numbers, count_numbers);
    this->tree = new vertex[tree_size];
    build_tree(numbers, 0, 0, count_numbers);
}


void Segment_Tree::set(int k, int x)
{
    int v = tree_size - 1 + k;
    tree[v].res = x;
    while (v > 0)
    {
        v = (v - 1) / 2;

        int l_min = tree[2 * v + 1].res;
        int r_min = tree[2 * v + 2].res;
        (l_min < r_min) ? tree[v].res = l_min : tree[v].res = r_min;
    }
}

int Segment_Tree::get_min(int node, int a, int b)
{
    int l = tree[node].left;
    int r = tree[node].right;
    if (r <= a || l >= b)
        return MAX;

    if (r < b & l >= a)
        return tree[node].res;

    int m1 = get_min(node * 2 + 1, a, b);
    int m2 = get_min(node * 2 + 2, a, b);
    return (m1 < m2) ? m1 : m2;
}

int Segment_Tree::find_spot(char* start_number)
{

    int start = stoi(start_number);
    int min_num = get_min(0, start, this->count_numbers - 1);

    if (min_num == MAX)
    {
        min_num = get_min(0, 0, start - 1);

        if (min_num == MAX)
            return -1;
        else
        {
            set(min_num - 1, MAX);
            return min_num;
        }
    }

    else
    {
        set(min_num - 1, MAX);
        return min_num;
    }
}

int Segment_Tree::free_up(char* number)
{
    int num = stoi(number);

    if (tree[num - 1].res == MAX)
    {
        set(num - 1, num);
        return 0;
    }
    else
        return -2;
}

int main()
{

    int n, m;
    cin >> n >> m;

    Segment_Tree tree;
    tree.Initialize(n);

    string s;
    for (int i = 0; i < m; ++i)
    {
        cin >> s;
        if (s[0] == '+')
            tree.find_spot(&s[3]);
        else
            tree.free_up(&s[3]);
    }

    return 0;
}