#include <fstream>
#include <assert.h>
#include <climits>

class Heap { 
private:
	int *values;
	int capacity;
	int nr_elements;
public:
	Heap(int capacity) {
		this->capacity = capacity;
		values = new int[capacity];
		nr_elements = 0;
	}

	~Heap() {
		delete [] values;
	}

	int parent(int poz) {
        return (poz - 1) / 2;
    }
 
    int left(int poz) {
        return (2 * poz + 1);
    }
 
    int right(int poz) {
        return (2 * poz + 2);
    }

    int insert(int x) {
    	++nr_elements;
    	int i = nr_elements - 1;
    	values[i] = x;

        while (i != 0 && values[parent(i)] > values[i]) {
            std::swap(values[i], values[parent(i)]);
            i = parent(i);
        }
    }

    int peak() {
    	return values[0];
    }

    void MinHeap(int i) {
        int l = left(i); 
        int r = right(i); 
        int smallest = i; 
        if (l < nr_elements && values[l] < values[i]) 
            smallest = l; 
        if (r < nr_elements && values[r] < values[smallest]) 
            smallest = r; 
        if (smallest != i) { 
            std::swap(values[i], values[smallest]); 
            MinHeap(smallest); 
        } 
    }

    void decrease(int i, int new_value) {
    	values[i] = new_value;

    	while (i != 0 && values[parent(i)] > values[i]) {
            std::swap(values[i], values[parent(i)]);
            i = parent(i);
        }
    }

    int extract_min() {

    	if (nr_elements == 1) {
    		--nr_elements;
    		return values[0];
    	}

    	int root = values[0];
    	values[0] = values[nr_elements - 1];
    	--nr_elements;
    	MinHeap(0);

    	return root;
    }

    void delete_element(int i) {
    	decrease(i, INT_MIN);
    	extract_min();
    }
};

int main() {
	std::ifstream cin("heapuri.in");
	std::ofstream cout("heapuri.out");
	std::ios::sync_with_stdio(false);

	int n, cod, x;

	cin >> n;
	Heap Heap(n);

	for (; n ; --n) {
		cin >> cod;

		switch(cod) {
			case 1: cin >> x;
					Heap.insert(x);
					break;
			case 2: cin >> x;
					Heap.delete_element(x);
					break;
			default: cout << Heap.extract_min() << '\n';
					break;
		}
	}

	return 0;
}