#include <iostream>
#include <cstring>

using namespace std;

struct Node {
    int data;
    int index;
};

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

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

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

void siftDown(Node* &arr, Node* &secondArr, int size, int ind, bool isMin){
    int left = leftSon(ind);
    int right = rightSon(ind);
    int indOfMax = ind;

    if (right < size && left < size && arr[right].data == arr[left].data &&
        (isMin ? arr[right].data < arr[ind].data : arr[right].data > arr[ind].data)){
        indOfMax = left;
    }
    else {
        if (left < size &&
            (isMin ? arr[left].data < arr[indOfMax].data : arr[left].data > arr[indOfMax].data)) {
            indOfMax = left;
        }

        if (right < size &&
            (isMin ? arr[right].data < arr[indOfMax].data : arr[right].data > arr[indOfMax].data)) {
            indOfMax = right;
        }
    }

    if (indOfMax != ind){
        swap(secondArr[arr[ind].index].index, secondArr[arr[indOfMax].index].index);
        swap(arr[ind], arr[indOfMax]);
        siftDown(arr, secondArr, size, indOfMax, isMin);
    }
}

void siftUp(Node* &arr, Node* &secondArr, int ind, bool isMin){
    int i = ind;
    while ((isMin ? arr[parent(i)].data > arr[i].data : arr[parent(i)].data < arr[i].data) && i > 0){
        swap(secondArr[arr[i].index].index, secondArr[arr[parent(i)].index].index);
        swap(arr[i], arr[parent(i)]);
        i = parent(i);
    }
}

int getMin(Node* &arrMin, Node* &arrMax) {
    return arrMin[0].data;
}

int getMax(Node* &arrMin, Node* &arrMax) {
    return arrMax[0].data;
}

void insert(Node* &arrMin, Node* &arrMax, int &size, int key) {
    Node elem;
    elem.data = key;
    elem.index = size;
    arrMin[size] = elem;
    arrMax[size] = elem;

    ++size;
    int tempSize = size - 1;
    siftUp(arrMin, arrMax, tempSize, true);
    tempSize = size - 1;
    siftUp(arrMax, arrMin, tempSize, false);
}

int extract(Node* &arr, Node* &secondArr, int size, int indToDelete, bool isMin) {
    swap(secondArr[arr[indToDelete].index].index, secondArr[arr[size - 1].index].index);
    swap(arr[indToDelete], arr[size - 1]);
    int result = arr[size - 1].data;
    --size;
    if (indToDelete < size){
        siftDown(arr, secondArr, size, indToDelete, isMin);
        siftUp(arr, secondArr, indToDelete, isMin);
    }
    return result;
}

void clear(Node* &arrMin, Node* &arrMax, int &size)
{
    size = 0;
}

int main(){
    int m;
    cin >> m;

    Node * arrMin = new Node[m];
    Node * arrMax = new Node[m];

    int size = 0;

    char task[15];

    for (int i = 0; i < m; ++i) {
        cin >> task;
        if (strcmp(task, "insert") == 0) {
            int key;
            cin >> key;
            insert(arrMin, arrMax, size, key);
            cout << "ok" << endl;
        }
        else if (strcmp(task, "extract_min") == 0) {
            if (size == 0) {
                cout << "error" << endl;
            }
            else {
                cout << getMin(arrMin, arrMax) << endl;
                extract(arrMin, arrMax, size, 0, true);
                extract(arrMax, arrMin, size, arrMin[size - 1].index, false);
                size--;
            }
        }
        else if (strcmp(task, "get_min") == 0) {
            if (size == 0) {
                cout << "error" << endl;
            }
            else {
                cout << getMin(arrMin, arrMax) << endl;
            }
        }
        else if (strcmp(task, "extract_max") == 0) {
            if (size == 0) {
                cout << "error" << endl;
            }
            else {
                cout << getMax(arrMin, arrMax) << endl;
                extract(arrMax, arrMin, size, 0, false);
                extract(arrMin, arrMax, size, arrMax[size - 1].index, true);
                size--;
            }
        }
        else if (strcmp(task, "get_max") == 0) {
            if (size == 0) {
                cout << "error" << endl;
            }
            else {
                cout << getMax(arrMin, arrMax) << endl;
            }
        }
        else if (strcmp(task, "size") == 0) {
            cout << size << endl;
        }
        else if (strcmp(task, "clear") == 0) {
            clear(arrMin, arrMax, size);
            cout << "ok" << endl;
        }
    }

    delete[] arrMax;
    delete[] arrMin;
}