#include <iostream>
#include <fstream>
#include <stdio.h>

using namespace std;

ifstream in("heapuri.in");
ofstream out("heapuri.out");

const int MAX_H = 200010;

int initialPoz[MAX_H];
int poz_size;

int pozHeap[MAX_H];

int heap[MAX_H];
int heap_size;

int parent( int i ){
  return ( i - 1 ) / 2;
}

int leftChild( int i ){
  return i * 2 + 1;
}

int rightChild( int i ){
  return i * 2 + 2;
}

int minimHeap(){
  return heap[0];
}

void afisareHeap();

void upHeap( int i ){
  while( i > 0 && heap[parent(i)] > heap[i] ){

    swap( heap[parent(i)], heap[i] );
    swap( pozHeap[initialPoz[parent(i)]], pozHeap[initialPoz[i]]);
    swap( initialPoz[parent(i)], initialPoz[i]);

    i = parent(i);
  }
}

int insertHeap( int val ){
  heap[heap_size] = val;

  //cout<<poz_size<<" "<<heap_size<<'\n';
  initialPoz[heap_size] = poz_size;
  pozHeap[poz_size] = heap_size;

  poz_size++;
  heap_size++;

  /*out<<"after inserti: "<<'\n';
  afisareHeap();*/

  upHeap(heap_size - 1);

  /*out<<"after upHeap: "<<'\n';
  afisareHeap();*/
}


void downHeap( int i ){
  int smallest;

  smallest = i;

  if( leftChild(i) < heap_size && heap[leftChild(i)] < heap[smallest] )
    smallest = leftChild(i);
  if( rightChild(i) < heap_size && heap[rightChild(i)] < heap[smallest] )
    smallest = rightChild(i);

  if( i != smallest ){
    swap( heap[smallest], heap[i] );
    swap( pozHeap[initialPoz[smallest]], pozHeap[initialPoz[i]]);
    swap( initialPoz[smallest], initialPoz[i]);

    downHeap(smallest);
  }
}

void eraseHeap( int i ){
   swap( heap[heap_size - 1], heap[i] );
   swap( pozHeap[initialPoz[heap_size - 1]], pozHeap[initialPoz[i]]);
   swap( initialPoz[heap_size - 1], initialPoz[i]);

   heap_size--;
   upHeap(i);
   downHeap(i);
}

void afisareHeap(){
  int i;
  for(i = 0; i < heap_size; i++ )
    out<<heap[i]<<" "<<initialPoz[i]<<" "<<pozHeap[initialPoz[i]]<<'\n';
}

int main(){
  int n, i, c, x;
  in>>n;

  heap_size = 0;
  poz_size = 0;
  for( i = 0; i < n; i++ ){
    in>>c;
    if( c == 1 ){
      in>>x;
      insertHeap(x);
    }
    if( c == 2 ){
      in>>x;
      eraseHeap(pozHeap[x - 1]);
    }
    else if( c == 3 )
      out<<minimHeap()<<'\n';
    /*out<<"heap and poz: "<<'\n';
    afisareHeap();
    out<<"poz_size etc: "<<poz_size<<" "<<heap_size<<'\n';*/
  }

  heap_size  = 1;
  return 0;
}