type plista=^lista;
     lista=record
           info:longint;
           urm:plista;
           end;
const myvarmem=sizeof(longint)*3+sizeof(byte);
      eroare=1024;
      maxmemdisp=16384*1024-myvarmem-eroare;
      maxmemnumere=1000000*sizeof(lista);
      m=(maxmemdisp-maxmemnumere)div sizeof(plista)-1;
type  hash=array[0..m]of plista;
var n,i,x:longint;
    op:byte;
    h:hash;


procedure inithash(var h:hash;m:longint);
var i:longint;
begin
for i:=1 to m do h[i]:=nil;
end;

procedure adaug(var h:hash;var x:longint);
var k:plista;
begin
k:=h[x mod m];
while k<>nil do if k^.info<>x then k:=k^.urm
                              else break;
if k=nil then
  begin
  new(k);
  k^.info:=x;
  k^.urm:=h[x mod m];
  h[x mod m]:=k;
  end;
end;

procedure sterge(var h:hash;var x:longint);
var k,l:plista;
begin
k:=h[x mod m];
if k=nil then exit;
if k^.info=x then
  begin
  h[x mod m]:=h[x mod m]^.urm;
  dispose(k);
  end
             else
  begin
  while(k^.urm<>nil)and(k^.urm^.info<>x)do k:=k^.urm;
  if k^.urm<>nil then
    begin
    l:=k^.urm;
    k^.urm:=l^.urm;
    dispose(l);
    end;
  end;
end;

procedure cautare(var h:hash;var x:longint);
var k:plista;
begin
k:=h[x mod m];
while(k<>nil)and(k^.info<>x)do k:=k^.urm;
if k=nil then writeln('0')
         else writeln('1');
end;

begin{
writeln('sizeof(longint) :',sizeof(longint));
writeln('sizeof(plista)  :',sizeof(plista));
writeln('sizeof(lista)   :',sizeof(lista));
writeln('sizeof(hash)    :',sizeof(hash));

writeln('myvarmem        =',myvarmem);
writeln('eroare          =',eroare);
writeln('maxmemdisp      =',maxmemdisp);
writeln('maxmemnumere    =',maxmemnumere);
writeln('m               =',m);}

assign(input,'hashuri.in');
assign(output,'hashuri.out');
rewrite(output);
reset(input);
readln(n);
inithash(h,m);
for i:=1 to n do
  begin
  readln(op,x);
  case op of
    1:adaug(h,x);
    2:sterge(h,x);
    3:cautare(h,x);
    end;
  end;
close(output);
close(input);
end.