#include <bits/stdc++.h>
using namespace std;
int chh;
const int N = 200005, INF = ~0U >> 2;
int n, m, e;
int h[N], cmd[N], id[N], p[N];
int a[N << 2], b[N << 2], c[N << 2], d[N << 2];
inline bool gr(int x, int y) {
  if (y % 2)
    return x > y + 1;
  else
    return x > y;
}
inline bool eq(int x, int y) {
  return x == y || (x % 2 && x + 1 == y) || (y % 2 && y + 1 == x);
}
inline void push_up(int k, int s, int t) {
  int l = k << 1, r = l + 1, mid = (s + t) >> 1, t1, t2;
  if (gr(a[l], a[r]) || eq(a[l], a[r]))
    a[k] = a[l], d[k] = d[l];
  else
    a[k] = a[r], d[k] = d[r];
  t1 = c[l] + b[r], t2 = mid - c[l] + 1;
  if (gr(t1, a[k]) || (eq(t1, a[k]) && t2 < d[k])) a[k] = t1, d[k] = t2;
  b[k] = b[l] == mid - s + 1 ? b[l] + b[r] : b[l];
  c[k] = c[r] == t - mid ? c[r] + c[l] : c[r];
}
void init(int k, int s, int t) {
  int mid = (s + t) >> 1;
  if (s == t)
    a[k] = b[k] = c[k] = 1, d[k] = s;
  else {
    init(k << 1, s, mid);
    init(k << 1 | 1, mid + 1, t);
    push_up(k, s, t);
  }
}
void update(int k, int s, int t, int x, int f) {
  int mid = (s + t) >> 1;
  if (s == t) {
    if (f)
      a[k] = b[k] = c[k] = 0, d[k] = -1;
    else
      a[k] = b[k] = c[k] = 1, d[k] = s;
  } else {
    if (x <= mid)
      update(k << 1, s, mid, x, f);
    else
      update(k << 1 | 1, mid + 1, t, x, f);
    push_up(k, s, t);
  }
}
struct NODE {
  int x, y;
  NODE() {}
  NODE(int X, int Y) : x(X), y(Y) {}
  bool operator<(const NODE& arg0) const {
    if (y != arg0.y) return y > arg0.y;
    return x < arg0.x;
  }
} dis[3];
int main() {
  int i, j;
  while (~scanf("%d %d", &n, &m)) {
    e = 0;
    for (i = 1; i <= m; i++) {
      scanf("%d %d", &cmd[i], &id[i]);
      h[e++] = id[i];
    }
    sort(h, h + e);
    e = unique(h, h + e) - h;
    for (i = 1; i <= m; i++) id[i] = lower_bound(h, h + e, id[i]) - h + 1;
    memset(p, -1, sizeof(p));
    init(1, 1, n);
    for (i = 1; i <= m; i++) {
      if (cmd[i] == 1) {
        dis[0] = NODE(1, b[1] - 1);
        if (a[1] == 0)
          dis[1] = NODE(INF, -1);
        else {
          j = (a[1] - 1) / 2;
          dis[1] = NODE(d[1] + j, j);
        }
        dis[2] = NODE(n, c[1] - 1);
        sort(dis, dis + 3);
        printf("%d\n", dis[0].x);
        p[id[i]] = dis[0].x;
        update(1, 1, n, dis[0].x, 1);
      } else {
        update(1, 1, n, p[id[i]], 0);
        p[id[i]] = -1;
      }
    }
  }
  return 0;
}
