Program HOTEL;

const filein='hotel.in';
      fileout='hotel.out';
      MAXN=100000;
      MAXB=100000;
      MAXS=210000;

type intarray=array[0..MAXN+1] of longint;
     dintarray=array[0..MAXS] of longint;
     longarray=array[0..MAXN+1] of longint;
     pint=^intarray;
     p2int=^dintarray;
     plong=^longarray;
     buffer=array[1..MAXB] of char;
     pbuf=^buffer;

var fin,fout:text;
    lungdr,heapld,pozhp:pint;
    fiu:array[1..2] of p2int;
    tata,li,ls,numdr:p2int;
    i,j,k,m,n,p,c,a,b,pd,last,size:longint;
    bufi,bufo:pbuf;

procedure initFiles;
begin
new(bufi);
fillchar(bufi^,sizeof(buffer),0);
new(bufo);
fillchar(bufo^,sizeof(buffer),0);

assign(fin,filein);
settextbuf(fin,bufi^,sizeof(buffer));
reset(fin);

assign(fout,fileout);
settextbuf(fout,bufo^,sizeof(buffer));
rewrite(fout);
end;

procedure initArrays;
begin
new(lungdr);
fillchar(lungdr^,sizeof(intarray),0);
lungdr^[1]:=n;

new(heapld);
fillchar(heapld^,sizeof(intarray),0);
new(pozhp);
fillchar(pozhp^,sizeof(intarray),0);

for i:=1 to n do
  begin
    heapld^[i]:=i;
    pozhp^[i]:=i;
  end;

new(tata);
fillchar(tata^,sizeof(dintarray),0);
new(li);
fillchar(li^,sizeof(dintarray),0);
new(ls);
fillchar(ls^,sizeof(dintarray),0);
new(numdr);
fillchar(numdr^,sizeof(dintarray),0);

for i:=1 to 2 do
  begin
    new(fiu[i]);
    fillchar(fiu[i]^,sizeof(dintarray),0);
  end;
end;

procedure closeFiles;
begin
close(fin);
close(fout);
end;

procedure MakeIntervals;
begin
last:=0;
for i:=1 to n do
  begin
    fiu[1]^[i]:=0; fiu[2]^[i]:=0;
    li^[i]:=i; ls^[i]:=i;
  end;
k:=n;

while (k>1) do
  begin
    j:=last+k; k:=0;
    for i:=last+1 to j do
      if ((i-last) and 1=1) then
        begin
          if (i+1<=j) then
            begin
              inc(k);
              tata^[i]:=j+k;
              tata^[i+1]:=j+k;
              li^[j+k]:=li^[i];
              ls^[j+k]:=ls^[i+1];
              fiu[1]^[j+k]:=i;
              fiu[2]^[j+k]:=i+1;
            end
          else
            begin
              inc(k);
              tata^[i]:=j+k;
              li^[j+k]:=li^[i];
              ls^[j+k]:=ls^[i];
              fiu[1]^[j+k]:=i;
              fiu[2]^[j+k]:=0;
            end;
        end;
    last:=j;
  end;

size:=last+k;
tata^[size]:=size+1;
end;

procedure up(poz:longint);
var php,ptata,vaux:longint;
begin
php:=pozhp^[poz];
ptata:=php shr 1;

while (ptata>0) and (lungdr^[heapld^[ptata]]<lungdr^[heapld^[php]]) do
  begin
    vaux:=heapld^[ptata];
    heapld^[ptata]:=heapld^[php];
    heapld^[php]:=vaux;

    pozhp^[heapld^[ptata]]:=ptata;
    pozhp^[heapld^[php]]:=php;

    php:=ptata;
    ptata:=php shr 1;
  end;
end;

procedure down(poz:longint);
var p1,p2,v1,v2,v,php:longint;
    sw:boolean;
begin
php:=pozhp^[poz];

repeat
sw:=false;

p1:=php shl 1;
p2:=p1+1;

if (p1<=n) then
  v1:=lungdr^[heapld^[p1]]
else
  v1:=-1;

if (p2<=n) then
  v2:=lungdr^[heapld^[p2]]
else
  v2:=-1;

v:=lungdr^[heapld^[php]];

if (v1>=v2) and (v1>v) then
  begin
    sw:=true;
    v:=heapld^[p1];
    heapld^[p1]:=heapld^[php];
    heapld^[php]:=v;

    pozhp^[heapld^[p1]]:=p1;
    pozhp^[heapld^[php]]:=php;

    php:=p1;
  end
else
if (v2>=v1) and (v2>v) then
  begin
    sw:=true;
    v:=heapld^[p2];
    heapld^[p2]:=heapld^[php];
    heapld^[php]:=v;

    pozhp^[heapld^[p2]]:=p2;
    pozhp^[heapld^[php]]:=php;

    php:=p2;
  end;
until (not sw);
end;

procedure searchok(nint:longint;var ppp:longint);
var f1,f2:longint;
begin
ppp:=0;
while (nint>n) do
  begin
    f1:=fiu[1]^[nint];
    f2:=fiu[2]^[nint];

    if (numdr^[f2]>0) then
      nint:=f2
    else
      nint:=f1;
  end;

ppp:=nint;
end;

procedure searchdr(lpoz:longint;var pp:longint);
var num,ii,l1:longint;
    ok:boolean;
begin
pp:=0;

ok:=false;
num:=lpoz;
while (ls^[num]=lpoz) and (num<=size) and (numdr^[num]=0) do
  num:=tata^[num];

if (num<=size) and (ls^[num]=lpoz) and (numdr^[num]>0) then
  searchok(num,pp)
else
if (num<size) and (ls^[num]>lpoz) then
  begin
    l1:=li^[num]-1;

    if (l1>0) then
      searchdr(l1,pp);
  end;
end;

procedure increase(poz:longint);
var ind:longint;
begin
ind:=poz;
while (ind<=size) do
  begin
    inc(numdr^[ind]);
    ind:=tata^[ind];
  end;
end;

procedure decrease(poz:longint);
var ind:longint;
begin
ind:=poz;
while (ind<=size) do
  begin
    dec(numdr^[ind]);
    ind:=tata^[ind];
  end;
end;

begin
initFiles;
readln(fin,n,p);
initArrays;
MakeIntervals;
increase(1);

while (p>0) do
  begin
    read(fin,c);
    if (c<3) then
      begin
        read(fin,a,m);
        b:=a+m-1;
      end;

    case c of
    1:begin
        searchdr(a,i);
        j:=i+lungdr^[i]-1;

        if (a=i) then
          begin
            lungdr^[i]:=0;
            decrease(i);
            down(i);
          end
        else
          begin
            lungdr^[i]:=a-i;
            down(i);
          end;

        if (b<j) then
          begin
           lungdr^[b+1]:=j-b;
           increase(b+1);
           up(b+1);
          end;
      end;
    2:begin
        searchdr(a,i);
        j:=i+lungdr^[i]-1;

        if (j=a-1) then
          begin
            if (lungdr^[b+1]>0) then
              begin
                pd:=b+lungdr^[b+1];

                lungdr^[i]:=pd-i+1;
                up(i);

                lungdr^[b+1]:=0;
                decrease(b+1);
                down(b+1);
              end
            else
              begin
                lungdr^[i]:=b-i+1;
                up(i);
              end;
          end
        else
          begin
            if (lungdr^[b+1]>0) then
              begin
                pd:=b+lungdr^[b+1];
                lungdr^[a]:=pd-a+1;
                increase(a);
                up(a);

                lungdr^[b+1]:=0;
                decrease(b+1);
                down(b+1);
              end
            else
              begin
                lungdr^[a]:=b-a+1;
                increase(a);
                up(a);
              end;
          end;
      end;
    3:begin
        writeln(fout,lungdr^[heapld^[1]]);
      end;
    end;

    dec(p);
  end;

closeFiles;

end.