#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N = 2e5 + 10;
#define int long long
#define ll long long
#define double long double

ll col = 0, cf = 0, cm[N];
int n, m;
set<ll> f;

// bool cmp[](pair<ll, pair<ll, ll>> a, pair<ll, pair<ll, ll>> b)
// {
//     if (a.first == b.first)
//     {
//         return (a.second.first + a.second.second) < (b.second.first + b.second.second);
//     }
//     return (a.first > b.first);
// }

set<pair<ll, pair<ll, ll>>> st;
ll val(ll pos)
{
    if (f.empty() || f.find(pos) != f.end())
        return -1e18 - 100;
    ll ret = 1e18 + 100;
    if (*f.rbegin() > pos)
    {
        auto it = f.upper_bound(pos);
        ret = min(ret, *it - pos);
    }
    if (*f.begin() < pos)
    {
        auto it = f.upper_bound(pos);
        it--;
        ret = min(ret, pos - *it);
    }
    return ret;
}
void add(ll pos)
{
    if (f.find(pos) != f.end())
    {
        exit(-1);
    }
    if (*f.rbegin() > pos && *f.begin() < pos)
    {
        auto it = f.upper_bound(pos);
        auto it1 = f.upper_bound(pos);
        it1--;
        st.erase({-(*it - *it1) + (*it - *it1) % 2, {*it1, *it}});
        st.insert({-(*it - pos) + (*it - pos) % 2, {pos, *it}});
        st.insert({-(pos - *it1) + (pos - *it1) % 2, {*it1, pos}});
    }
    else
    {
        if (*f.rbegin() > pos)
        {
            auto it = f.upper_bound(pos);
            st.insert({-(*it - pos) + ((*it - pos) % 2), {pos, *it}});
        }
        else if (*f.begin() < pos)
        {
            auto it1 = f.upper_bound(pos);
            it1--;
            st.insert({-(pos - *it1) + (pos - *it1) % 2, {*it1, pos}});
        }
        else
        {
            exit(-1);
        }
    }
    cout << pos << '\n';
    f.insert(pos);
    cm[cf] = pos;
}
main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        char t;
        cin >> t;
        if (t == '+')
        {
            cf++;
            if (!col)
            {
                cout << 1 << '\n';
                cm[cf] = 1;
                f.insert(1);
            }
            else
            {
                vector<pair<ll, ll>> g;
                g.push_back({-val(1), 1});
                g.push_back({-val(n), n});
                int it = 0;
                ll lst = 1e18 + 1;
                for (auto [x, y] : st)
                {
                    it++;
                    if (it == 2)
                        break;
                    ll pos = (y.first + y.second) >> 1;
                    g.push_back({-val(pos), pos});
                    assert(x <= 0);
                    assert(abs(x) <= lst);
                    lst = abs(x);
                }
                // if (!st.empty())
                // {
                //     auto [x, y] = (*st.begin());
                //     ll pos = (y.first + y.second) / 2;
                //     g.push_back({-val(pos), pos});
                // }
                // for(int k = 1;k <= n;k++){
                //     g.push_back({-val(k),k});
                // }
                sort(g.begin(), g.end());
                add(g[0].second);
            }
            col++;
        }
        else
        {
            col--;
            ll x;
            cin >> x;
            x = cm[x];
            ll pos = x;
            f.erase(pos);
            if (f.empty())
                continue;
            if (*f.rbegin() > pos && *f.begin() < pos)
            {
                auto it = f.upper_bound(pos);
                auto it1 = f.upper_bound(pos);
                it1--;
                st.insert({-(*it - *it1) + (*it - *it1) % 2, {*it1, *it}});
                st.erase({-(*it - pos) + (*it - pos) % 2, {pos, *it}});
                st.erase({-(pos - *it1) + (pos - *it1) % 2, {*it1, pos}});
            }
            else
            {
                if (*f.rbegin() > pos)
                {
                    auto it = f.upper_bound(pos);
                    st.erase({-(*it - pos) + (*it - pos) % 2, {pos, *it}});
                }
                else if (*f.begin() < pos)
                {
                    auto it1 = f.upper_bound(pos);
                    it1--;
                    st.erase({-(pos - *it1) + (pos - *it1) % 2, {*it1, pos}});
                }
                else
                {
                    exit(-1);
                }
            }
        }
    }
}