#include <cstdio>
#include <iostream>
#define MAX 200005

using namespace std;

int N;
typedef int Heap[MAX];
// Pos: chronological order -> heap index , A: heap index -> chronological order
int Pos[MAX], A[MAX];

inline int parent(int nod) {
  return nod/2;
}

inline int left_child(int nod) {
  return 2*nod;
}

inline int right_child(int nod) {
  return 2*nod + 1;
}

inline int min(Heap H) {
  return printf("%d\n", H[1]);
}

void down(Heap H, int total_index, int curr_index) {
  int child_index;
  int sift = 1;
  do {
    int left_index = left_child(curr_index);
    int right_index = right_child(curr_index);

    if(left_index <= total_index) {
      child_index = left_index;
      
      if(right_index <= total_index && H[left_index] > H[right_index]) {
        child_index = right_index;
     }
    }
    if(H[child_index] >= H[curr_index]) {
        sift = 0;
    }
    if(sift) {
      int curr_o = A[curr_index];
      int child_o = A[child_index];
      swap(H[child_index], H[curr_index]);
      Pos[child_o] = curr_index;
      Pos[curr_o] = child_index;
      A[curr_index] = child_o;
      A[child_index] = curr_o;
      curr_index = child_index;
    }
  } while(sift);
}

void up(Heap H, int total_index, int curr_index) {
  int curr_val = H[curr_index];
  int curr_o = A[curr_index];

  while(curr_index > 1 && curr_val < H[parent(curr_index)]) {
    int po = A[parent(curr_index)];
    H[curr_index] = H[parent(curr_index)];
    Pos[po] = curr_index;
    A[curr_index] = po; 
    curr_index = parent(curr_index);
  }
  H[curr_index] = curr_val;
  Pos[curr_o] = curr_index; 
  A[curr_index] = curr_o;
} 

int main() {
  freopen("heapuri.in", "r", stdin);
  freopen("heapuri.out", "w", stdout);
  
  scanf("%d", &N);
  int code, num;
  Heap H;
  int n = 0;
  int o = 0;
  for(int i = 0; i < N; i++) {
    scanf("%d", &code);
    if(code == 1) {
      scanf("%d", &num);
      H[++n] = num;
      Pos[++o] = n; // n should be modified in 
      A[n] = o; // n should be modified in up
      up(H, n, n); 
    } else if(code == 2) {
      scanf("%d", &num);
      Pos[A[n]] = Pos[num];
      A[Pos[num]] = A[n];
      int curr_index = Pos[num];
      H[curr_index] = H[n];
      n--;
      // decide whether to call up or down
      if(parent(curr_index) > 0 && H[parent(curr_index)] > H[curr_index]) {
        up(H, n, curr_index);
      } else if(left_child(curr_index) <= n) {
        down(H, n, curr_index);
      } 
    } else if(code == 3) {
      min(H);
    } 
  }
  return 0;
}