#include <stdio.h>
#include <vector>
#include <list>
#include <map>
#include <array>
#include <memory>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <unordered_map>
#include <stdexcept>


using std::string;
using std::vector;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::vector<std::string> split(const std::string& input, char delimiter)
{
    std::istringstream stream(input);

    std::string field;
    std::vector<std::string> result;
    while (std::getline(stream, field, delimiter)) {
        result.push_back(field);
    }
    return result;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// user func
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void printList(const vector<int>& list) {
    // print
    for(int i = 0; i < list.size(); i++){
        printf(" %d", list[i]);
    }
    printf("\n");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// logic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int LeftIndex(const vector<int> &list, int index){
    if (list.size() - 1 < index * 2) return 0;
    return index * 2;
}
int RightIndex(const vector<int>&list, int index){
    if (list.size() - 1 < index * 2 + 1) return 0;
    return index * 2 + 1;
}

void MaxHeapfy(vector<int>& list, int index){
    int left = LeftIndex(list, index);
    int right = RightIndex(list, index);
    int largestIndex = index;
    if (list[largestIndex] < list[left]){
        largestIndex = left;
    }
    if (list[largestIndex] < list[right]){
        largestIndex = right;
    }
    if (largestIndex != index) {
        std::swap(list[index], list[largestIndex]);
        MaxHeapfy(list, largestIndex);
    }
}

void BuildMaxHeap(vector<int>& list){
    for (int i = list.size() -1 ; 1 < i; i = i/2) {
        if(list[i/2] < list[i]){
            std::swap(list[i], list[i / 2]);
        }else{
            break;
        }
    }
}

void Insert(std::vector<int>& list, int value){
    list.push_back(value);
    BuildMaxHeap(list);
    // auto it = list.rbegin();
    // for (; it != list.rend(); it++ ){
    //     if (*it < value){
    //         break;
    //     }
    // }
    // list.insert(it.base(), value);
}
int Extract(std::vector<int>& list){
    int result = list[1];
    int back = list.back();
    list[1] = back;
    list.pop_back();
    MaxHeapfy(list, 1);
    return result;
    // auto max = std::max_element(list.begin(), list.end());
    // int result = *max;
    // list.erase(max);
    // return result;
}

void solve() {
    // priority queue
    std::vector<int> list;
    list.push_back(std::numeric_limits<int>::min());
    char buffer[32];
    while (true){
        scanf("%s", buffer);
        string command(buffer);
        if (command == "insert") {
            int v;
            scanf(" %d", &v);
            Insert(list, v);
        } else if (command == "extract") {
            int v = Extract(list);
            printf("%d\n", v);
        } else if (command == "end") {
            break;
        } else {
            printf("error\n");
            break;
        }
    }
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
    solve();
    return 0;
}


Measured memory_bytes: 7068