void main(){
  import std.stdio, std.conv, std.string, std.algorithm;

  auto h=new MyBinaryHeap!(int, "a>b");
  while(1){
    auto args=readln.split.to!(string[]);
    if(args[0][0]=='e'){
      if(args[0][1]=='n') break;
      writeln(h.front);
      h.removeFront;
    }else{
      auto k=args[1].to!(int);
      h.insert(k);
    }
  }
}

import std.functional : binaryFun;

class MyBinaryHeap(T, alias less = "a<b")
    if (is(typeof(binaryFun!less(T.init, T.init))))
{
  import std.range.primitives : _front = front, _back = back, _empty = empty,
    popBack;
  import std.exception : enforce;
  import std.algorithm.iteration : each;
  import std.algorithm.mutation : swap;

  private T[] dat;
  private alias comp = binaryFun!(less);

  this(T[] arr = [])
  {
    arr.each!(x => insert(x));
  }

  void insert(T x)
  {
    size_t i = dat.length;
    dat ~= x;
    while (i > 0)
    {
      size_t p = (i - 1) / 2;
      if (comp(dat[i], dat[p]))
      {
        swap(dat[i], dat[p]);
        i = p;
      }
      else
      {
        break;
      }
    }
  }

  T front()
  {
    enforce(dat.length > 0, "Cannot call front on an empty heap.");
    return dat._front;
  }

  void removeFront()
  {
    enforce(dat.length > 0, "Cannot call removeFront on an empty heap.");
    swap(dat._front, dat._back);
    dat.popBack;
    size_t len = dat.length;
    size_t i = 0;
    while (i * 2 + 1 < len)
    {
      if (i * 2 + 2 < len)
      {
        // 左右で強いほうの子と比べる
        size_t j = comp(dat[i * 2 + 1], dat[i * 2 + 2]) ? i * 2 + 1 : i * 2 + 2;
        if (comp(dat[j], dat[i]))
        {
          swap(dat[j], dat[i]);
          i = j;
        }
        else
        {
          break;
        }
      }
      else // 左の子しかない
      {
        if (comp(dat[i * 2 + 1], dat[i]))
        {
          swap(dat[i * 2 + 1], dat[i]);
          i = i * 2 + 1;
        }
        else
        {
          break;
        }
      }
    }
  }

  bool empty()
  {
    return dat._empty;
  }
}

