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

using namespace std;

#define NMAX 200002

int heap[NMAX];
int heapsize;
int pozsize;
int init[NMAX];
int poz[NMAX];


static inline int leftchild(int i) {
    return 2*i+1;
}
static inline int rightchild(int i) {
    return 2*i+2;
}
static inline int parent(int i) {
    return (i-1)/2;
}

void upheap(int nod) {
    int father, aux;
    if (nod>0) {
        father = parent(nod);
        if (heap[father]>heap[nod]) {
            swap(heap[father], heap[nod]);
            swap(poz[init[father]], poz[init[nod]]);
            swap(init[father], init[nod]);
        }
        upheap(father);
    }
}

void addval(int val)  {
    heap[heapsize] = val;
    init[heapsize] = pozsize;
    poz[pozsize] = heapsize;
    pozsize++;
    heapsize++;
    upheap(heapsize-1);
}

void downheap(int nod) {
    int mini, st, dr;
    
    mini = nod;
    st = leftchild(nod);
    dr = rightchild(nod);
    
    if (st<heapsize && heap[st]<heap[mini]) {
        mini = st;
    }
    if (dr<heapsize && heap[dr]<heap[mini]) {
        mini = dr;
    }
 
    if (mini!=nod) {
        swap(heap[mini], heap[nod]);
        swap(poz[init[mini]], poz[init[nod]]);
        swap(init[mini], init[nod]);
        downheap(mini);
    }
}

void del(int nod){
   swap(heap[heapsize-1], heap[nod]);
   swap(poz[init[heapsize-1]], poz[init[nod]]);
   swap(init[heapsize-1], init[nod]);

   heapsize--;
   upheap(nod);
   downheap(nod);
}

int main() {
    FILE *fin, *fout;
    fin = fopen("heapuri.in", "r");
    fout = fopen("heapuri.out", "w");
    
    int nrop, i, op, val, p;
    
    fscanf(fin, "%d", &nrop);
    
    for (i=0; i<nrop; i++) {
        fscanf(fin, "%d", &op);
        if (op==1) {
            fscanf(fin, "%d", &val);
            addval(val);
        } else if (op==2) {
            fscanf(fin, "%d", &p);
            p--;
            del(poz[p]);
        } else if (op==3) {
            fprintf(fout, "%d\n", heap[0]);
        }
    }
    
    fclose(fin);
    fclose(fout);
    return 0;
}