Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Priority Queue

A priority queue is a data structure which maintains a set $S$ of elements, each of with an associated value (key), and supports the following operations:

$insert(S, k)$: insert an element $k$ into the set $S$

$extractMax(S)$: remove and return the element of $S$ with the largest key

Write a program which performs the $insert(S, k)$ and $extractMax(S)$ operations to a priority queue $S$.
The priority queue manages a set of integers, which are also keys for the priority.

Input

Multiple operations to the priority queue $S$ are given. Each operation is given by "insert $k$", "extract" or "end" in a line. Here, $k$ represents an integer element to be inserted to the priority queue.

The input ends with "end" operation.

Output

For each "extract" operation, print the element extracted from the priority queue $S$ in a line.

Constraints

The number of operations $\leq 2,000,000$

$0 \leq k \leq 2,000,000,000$

Sample Input 1

insert 8
insert 2
extract
insert 10
extract
insert 11
extract
extract
end

Sample Output 1

8
10
11
2

Solution in Haskell (judge verdict: Memory Limit Exceeded)

import Control.Applicative ((<$>))
import Control.Monad (foldM)
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as B

main :: IO ()
main = map B.words <$> B.lines <$> B.getContents >>= solve

solve :: [[ByteString]] -> IO ()
solve bs = foldM f Leaf bs >> return ()
  where f hp [_, bn] = return $ hpInsert (readi B.readInt bn) hp
        f hp [com] | com == end = return hp
                   | otherwise = do
                       let Just (x, hp') = hpView hp
                       print x
                       return hp'
        end = B.pack "end"

data Heap a = Leaf | Node a (Heap a) (Heap a) deriving Show

hpInsert :: (Ord a) => a -> Heap a -> Heap a
hpInsert x hp = hpMergeBy (flip compare) hp (Node x Leaf Leaf)

hpView :: (Ord a) => Heap a -> Maybe (a, Heap a)
hpView hp = hpViewBy (flip compare) hp

hpMergeBy :: (Ord a) => (a -> a -> Ordering) -> Heap a -> Heap a -> Heap a
hpMergeBy _ Leaf Leaf = Leaf
hpMergeBy _ Leaf hp = hp
hpMergeBy _ hp Leaf = hp
hpMergeBy f (Node x xlt xrt) (Node y ylt yrt) =
  case f x y of
   LT -> Node x (hpMergeBy f xrt (Node y ylt yrt)) xlt
   _ ->  Node y (hpMergeBy f yrt (Node x xlt xrt)) ylt

hpViewBy :: (Ord a) => (a -> a -> Ordering) -> Heap a -> Maybe (a, Heap a)
hpViewBy f Leaf = Nothing
hpViewBy f (Node x xlt xrt) = Just (x, hpMergeBy f xlt xrt)

readi :: Integral a =>  (ByteString -> Maybe (a, ByteString)) -> ByteString -> a
readi f s = let Just (n, _) = f s in n