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 C# (judge verdict: Runtime Error)

using System;
using System.Text;
					
public class Program
{
	static int H = 0;
	
	public static void Main()
	{
		int[] S = new int[21];//[2000001];
		string order;
		StringBuilder sb = new StringBuilder();
		
		// Insert(S, 8);
		// Insert(S, 7);
		// Insert(S, 2);
		// sb.AppendLine(Extract(S).ToString());
		// Insert(S, 19);
		// Insert(S, 10);
		// sb.AppendLine(Extract(S).ToString());
		// sb.AppendLine(Extract(S).ToString());
		// Insert(S, 8);
		// sb.AppendLine(Extract(S).ToString());
		// sb.AppendLine(Extract(S).ToString());
		// Insert(S, 3);
		// Insert(S, 4);
		// Insert(S, 1);
		// sb.AppendLine(Extract(S).ToString());
		// sb.AppendLine(Extract(S).ToString());
		// sb.AppendLine(Extract(S).ToString());
		

		order = Console.ReadLine();
		
		while(order != "end") {
			switch(order[0]) {
				case 'e':
					sb.AppendLine(Extract(S).ToString());
					break;
				case 'i':
					Insert( S, 
						int.Parse(order.Split(" ".ToCharArray())[1]) );
					break;
			}
			
			order = Console.ReadLine();
		}
		
		Console.Write(sb);
	}
	
	public static int Extract(int[] A)
	{
		int ret;
		
		if (H < 1) return int.MinValue;
		
		ret = A[1];
		A[1] = A[H--];
		
		MaxHeapify(A, 1);	
		
		return ret;
	}
	
	public static void Insert(int[] A, int key)
	{
		H++;
		A[H] = int.MinValue;
		
		IncreaseKey(A, H, key);
	}
	
	public static void IncreaseKey(int[] A, int i, int key)
	{
		if(key < A[i]) return;
		A[i] = key;
		
		while(i > 1 && A[i] > A[i/2]) {
			Swap(A, i, i/2);
			i /= 2;
		}
	}
	
	public static void MaxHeapify(int[] A, int i)
	{
		int l = Left(A, i);
		int r = Right(A, i);
		int largest = i;
		
		if(l >= 0) {
			if(A[l] > A[largest]) largest = l;	
		}
		if(r >= 0) {
			if(A[r] > A[largest]) largest = r;
		}
		
		if(i != largest) {
			Swap(A, i, largest);
			MaxHeapify(A, largest);
		}
	}
	
	public static int Left(int[] A, int i)
	{	
		return ( 2*i <= H )? 2*i : -1;
	}
	
	public static int Right(int[] A, int i)
	{	
		return ( (2 * i + 1) <= H)? (2*i + 1) : -1;
	}
	
	public static void Swap(int[] A, int i, int j)
	{
		int tmp = A[i];
		A[i] = A[j];
		A[j] = tmp;
	}
}