public static void main(String[] args) {
    int[] heap = new int[16];
    int last = 1;
    Scanner in = new Scanner(System.in);
    int queries = in.nextInt();
    for (int q=0; q<queries; q++) {
      int op = in.nextInt();
      switch (op) {
        case 1:
          int value = in.nextInt();
          if (last == heap.length) {
            heap = doubleSizeOf(heap);
          }
          heap[last] = value;
          swim(heap, last);
          last++;
          break;
        case 2:
          value = in.nextInt();  
          int posToDelete = findInHeap(heap, value, last);
          last--;
          swap(heap, posToDelete, last);
          sink(heap, posToDelete, last);
          swim(heap, posToDelete);
          break;
        case 3:
          if (last > 1) {
            System.out.println(heap[1]); 
          }
          break;
        default:
          ;
      }
    }
    in.close();
  }
  
  private static int[] doubleSizeOf(int[] heap) {
    int [] doubleHeap = new int[heap.length*2];
    for (int i=0; i<heap.length; i++) {
      doubleHeap[i] = heap[i];
    }
    return doubleHeap;
  }

  private static void swim(int[] heap, int pos) {
    int parent = pos/2;
    while (parent>0 && heap[pos]<heap[parent]) {
      swap(heap, parent, pos);
      pos = parent;
      parent = pos/2;
    }
  }
  
  private static void swap(int[] heap, int from, int to) {
    int temp = heap[from];
    heap[from] = heap[to];
    heap[to] = temp;
  }

  private static int findInHeap(int[] heap, int key, int last) {
    return findInHeapStartingFrom(heap, key, last, 1);
  }
  
  private static int findInHeapStartingFrom(int[] heap, int key, int last, int pos) {
    if (last <= pos) {
      return -1;
    }
    if (heap[pos] == key) {
      return pos;
    }
    int foundInLeft = findInHeapStartingFrom(heap, key, last, pos*2);
    if (foundInLeft > -1) {
      return foundInLeft;
    }
    return findInHeapStartingFrom(heap, key, last, pos*2+1);
  }

  private static void sink(int[] heap, int pos, int last) {
    int left = pos*2;
    int right = pos*2+1;
    int posToSwap = pos;
    if (left<last && heap[left]<heap[posToSwap]) {
      posToSwap = left;
    }
    if (right<last && heap[right]<heap[posToSwap]) {
      posToSwap = right;
    }
    if (pos == posToSwap) {
      return;
    }
    swap(heap, pos, posToSwap);
    sink(heap, posToSwap, last);
  }

#include<bits/stdc++.h>
using namespace std;

#define NN 100000 //Heap size

struct minHeap{
    int n; //number of nodes in heapArr
    int heapArr[NN+1]; //array is 1 based
    minHeap(){ n=0 ;}
    void min_heapify(int index);
    void insert(int k);
    int search(int k);
    void deleteKey(int k);
    int getMin();
};
void minHeap::min_heapify(int i){
        int l = 2*i;
        int r = 2*i+1;
        int min = i;
        if(l<n && heapArr[l]<heapArr[min])
            min = l;
        if(r<n && heapArr[r]<heapArr[min])
            min = r;
        if(min != i){
            swap(heapArr[i],heapArr[min]);
            min_heapify(min);
        }
    }
void minHeap::insert(int k){
        if(n==NN) return;
        n++;
        heapArr[n]= k;
        int p= n;
        while(p>1){
            int pr= p/2;
            if(heapArr[pr]>heapArr[p]){
                swap(heapArr[pr],heapArr[p]);
                p= pr;
            }
            else break;
        }
}
int minHeap::getMin(){
    if(n==0) return -1;
    else return heapArr[1];
}

int minHeap::search(int ele){
    for(int i=1;i<=n;i++){
        if(heapArr[i] == ele)
            return i;
        }
        return -1;
    }

void minHeap::deleteKey(int ele){
        int index = search(ele);
        heapArr[index] = heapArr[n];
        n--;
        min_heapify(index);
    }
int main(){
    minHeap h;
    int q, t, x;
    cin>>q;
    while(q--){
        cin>>t;
        if(t==1){
            cin>>x;
            h.insert(x);
        }
        else if(t==2){
            cin>>x;
            h.deleteKey(x);
        }
        else{
            cout<<h.getMin()<<endl;
        }
    }
}

from sys import stdin
from heapq import heappush, heappop

heap = []
item_lookup = set()

def push(v):
    heappush(heap, v)
    item_lookup.add(v)
    
def discard(v):
    item_lookup.discard(v)
    
def print_min():
    while heap[0] not in item_lookup:
        heappop(heap)
      
    print heap[0]
    
cmds = {
    1: push,
    2: discard,
    3: print_min
}

n = int(stdin.readline())
for _ in range(n):
    data = map(int,stdin.readline().split(" "))
    cmds[data[0]](*data[1:])

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        PriorityQueue<Integer> pQueue = new PriorityQueue<Integer>();
        
        for(int i = 0; i < n; i++) {
            int q = sc.nextInt();
            switch(q) {
                case 1 : 
                    pQueue.add(sc.nextInt());
                    break;
                case 2 : 
                    pQueue.remove(sc.nextInt());
                    break;
                case 3 : 
                    System.out.println(pQueue.peek());
                    break;
            }
        }
    }
}

from heapq import heappush, heappop

valheap = []
delheap = []

q = int(input().strip())

for i in range(q):

    lst = list(map(int, input().strip().split(' ')))

    if lst[0] == 1:
        heappush(valheap, lst[1])

    elif lst[0] == 2:

        if valheap[0] == lst[1]:
            heappop(valheap)
        else:
            heappush(delheap, lst[1])

    elif lst[0] == 3:

        check = bool(delheap)

        while check:
            if delheap[0] == valheap[0]:
                heappop(delheap)
                heappop(valheap)
                check = bool(delheap)
            else:
                check = False

        print (valheap[0])

26
1 1
1 2
1 10
1 3
1 4
1 11
1 12
1 5
1 6
1 7
1 8
1 13
1 14
1 15
1 16
1 9
2 11
2 8
2 7
2 6
2 5
2 4
2 3
2 2
2 1
3