#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int n, q, d, l, r;
map<int, int> exist;
struct node {
  int l, r, v, min, max, p, s;
  pair<int, int> len;
};
struct Treap {
  int cnt, root;
  node T[100010];
  inline void upd(int x) {
    T[x].max = max(max(T[T[x].l].max, T[T[x].r].max), T[x].v);
    T[x].min = min(min(T[T[x].l].min, T[T[x].r].min), T[x].v);
    pair<int, int> a(T[x].v - T[T[x].l].max - 1,
                     (T[x].v + T[T[x].l].max + 1) / 2),
        b(T[T[x].r].min - T[x].v - 1, (T[x].v + T[T[x].r].min + 1) / 2);
    if (T[x].l == 0) a.first = -1;
    if (T[x].r == 0) b.first = -1;
    T[x].len = max(max(a, b), max(T[T[x].l].len, T[T[x].r].len));
    T[x].s = T[T[x].l].s + T[T[x].r].s + 1;
  }
  inline int rr(int x) {
    int k = T[x].l;
    T[x].l = T[k].r;
    T[k].r = x;
    upd(x);
    upd(k);
    return k;
  }
  inline int lr(int x) {
    int k = T[x].r;
    T[x].r = T[k].l;
    T[k].l = x;
    upd(x);
    upd(k);
    return k;
  }
  int insert(int x, int v, int p) {
    if (x == 0) {
      cnt++;
      T[cnt].l = T[cnt].r = T[cnt].len.first = 0;
      T[cnt].p = p;
      T[cnt].v = T[cnt].min = T[cnt].max = T[cnt].len.second = v;
      T[cnt].s = 1;
      T[cnt].p = p;
      return cnt;
    }
    if (v < T[x].v) {
      T[x].l = insert(T[x].l, v, p);
      upd(x);
      if (T[T[x].l].p < T[x].p)
        return rr(x);
      else
        return x;
    } else {
      T[x].r = insert(T[x].r, v, p);
      upd(x);
      if (T[T[x].r].p < T[x].p)
        return lr(x);
      else
        return x;
    }
  }
  inline int ins(int x) {
    int ret = T[root].len.second;
    root = insert(root, ret, rand());
    return ret;
  }
  inline int del(int x, int v) {
    if (T[x].v == v) {
      int ret;
      if (T[x].l == 0 && T[x].r == 0) return 0;
      if (T[T[x].l].p < T[T[x].r].p)
        ret = rr(x), T[ret].r = del(x, v);
      else
        ret = lr(x), T[ret].l = del(x, v);
      upd(ret);
      return ret;
    } else if (T[x].v > v)
      T[x].l = del(T[x].l, v);
    else
      T[x].r = del(T[x].r, v);
    upd(x);
    return x;
  }
  int sum(int x, int v) {
    if (x == 0) return 0;
    if (T[x].v > v)
      return sum(T[x].l, v);
    else
      return T[T[x].l].s + 1 + sum(T[x].r, v);
  }
  inline int query(int l, int r) {
    int ret = sum(root, r) - sum(root, l - 1);
    return ret;
  }
} T;
int main() {
  srand((int)time(0));
  cin.sync_with_stdio(false);
  cout.sync_with_stdio(false);
  cin >> n >> q;
  T.root = 0;
  T.T[0].min = 1 << 30;
  T.T[0].max = -(1 << 30);
  T.T[0].p = 1 << 30;
  T.root = T.insert(0, 0, rand());
  T.root = T.insert(T.root, n + 1, rand());
  for (; q; q--) {
    cin >> d;
    if (d == 0) {
      cin >> l >> r;
      cout << T.query(l, r) << endl;
    } else {
      if (exist.count(d) > 0) {
        map<int, int>::iterator x = exist.find(d);
        T.root = T.del(T.root, x->second);
        exist.erase(d);
      } else {
        int x = T.ins(d);
        exist.insert(make_pair(d, x));
      }
    }
  }
  return 0;
}
