import java.io$.*$; import java.math.$*$; import java.text.$*$; import java.util.$*$;

import java.util.concurrent.$*$; import java.util.function.$*$;import java.util.regex.$*$;

interface IBinaryHeap $\{$

public void add$($int item$)$;

public int remove$()$;

public int size$()$;

public int peek$()$;$\}$

class BinaryHeap implements IBinaryHeap $\{$

private final int INITIAL$\_$SIZE $=10$;

private List arrList;

private int size;

public BinaryHeap$()\{$

this.size $=0$;

this.arrList $=$ new ArrayList$($INITIAL$\_$SIZE$)$;

this.arrList.add$($Integer$.$MAX$\_$VALUE$)$;$\}$

public void print$()\{$

String elements $="["$;

$//$ We're not using the first element

for $($int i $=0$; i $<$ arrList.size$()$; i$++)\{$

if $($i $==0)\{$

elements $+="$X$"$;

$\}$ else $\{$

elements $+=$ arrList.get$($i$)$;$\}$

if $($i $<$ arrList.size$()-1)\{$

elements $+=","$; $\}\}$

elements $+="]"$;

String summary $=$ String.format$("\{$ size: $\%$d$,$ elements: $\%$s $\}",$ this.size, elements$)$;

System.out.println$($summary$)$;$\}$

$//$ Write all your code BELOW here...

@Override

public void add$($int item$)\{/*$ Write here$*/\}$

@Override

public int remove$()\{/*$ Write here$*/\}$

@Override

public int size$()\{/*$ Write here$*/\}$

@Override

public int peek$()\{/*$ Write here$*/\}$

private void heapifyUp$($int nodeIndex$)\{/*$ Write here$*/\}$

private void heapifyDown$($int nodeIndex$)\{/*$ Write here$*/\}$

private int getLeftChildIndex$($int nodeIndex$)\{/*$ Write here$*/\}$

private int getRightChildIndex$($int nodeIndex$)\{/*$ Write here$*/\}$

private int getParentIndex$($int nodeIndex$)\{/*$ Write here$*/\}$

private boolean haveLeftChild$($int nodeIndex$)\{/*$ Write here$*/\}$

private boolean haveRightChild$($int nodeIndex$)\{/*$ Write here$*/\}$

private void swap$($int index$1,$ int index$2)\{/*$ Write here$*/\}$

$\}$

interface IMaxPriorityQueue $\{$

public void addItem$($int item$)$;

public int removeItem$()$;

public int peek$()$;

public int getSize$()$;

public boolean isEmpty$()$;$\}$

class MaxPriorityQueue implements IMaxPriorityQueue $\{$

private BinaryHeap binaryHeap;

public MaxPriorityQueue$()\{$

this.binaryHeap $=$ new BinaryHeap$()$; $\}$

public void print$()\{$

this.binaryHeap.print$()$; $\}$

$/*$Implement the IMaxPriorityQueue.$*/$

@Override

public void addItem$($int item$)\{/*$ Write here$*/\}$

@Override

public int removeItem$()\{/*$ Write here$*/\}$

@Override

public int peek$()\{/*$ Write here$*/\}$

@Override

public int getSize$()\{/*$ Write here$*/\}$

@Override

public boolean isEmpty$()\{/*$ Write here$*/\}$

class Solution $\{$

public static void main$($String$[]$ args$)$ throws IOException $\{$

BufferedReader bufferedReader $=$ new BufferedReader$($new InputStreamReader$($System$.$in$))$;

int operationCount $=$ Integer.parseInt$($bufferedReader$.$readLine$().$replaceAll$("\backslash \backslash$s$+$$$","").$split$("=")[1].$trim$())$;

bufferedReader.readLine$()$;

MaxPriorityQueue queue $=$ new MaxPriorityQueue$()$;

IntStream.range$(0,$ operationCount$).$forEach$($opCountItr $->\{$

try $\{$

List theInput $=$ Stream.of$($bufferedReader$.$readLine$().$replaceAll$("\backslash \backslash$s$+$$$","").$split$("\backslash \backslash ("))$

$.$collect$($toList$())$;

String action $=$ theInput.get$(0)$;

String argsString $=$ theInput.get$(1)$;

argsString $=$ argsString.substring$(0,$ argsString.length$()-1)$;

String arg$0=$ null;

if $($argsString$.$length$()>0)\{$

List argsInput $=$ Arrays.asList$($argsString$.$split$(","))$;

arg$0=$ argsInput.size$()>0?$ argsInput.get$(0).$trim$()$ : null; $\}$

ProcessInputs$($queue$,$ action, arg$0)$; $\}$ catch $($IOException exception$)\{$

throw new RuntimeException$($exception$)$;$\}$

$\})$;

bufferedReader.close$()$; $\}$

private static void ProcessInputs$($MaxPriorityQueue queue, String action, String arg$0)\{$

int value;

switch $($action$)\{$

case "addItem":value $=$ Integer.parseInt$($arg$0)$;queue.addItem$($value$)$;break;

case "removeItem":

if$($queue$.$isEmpty$())\{$System$.$out.println$("$QUEUE$\_$IS$\_$EMPTY"$)$;

$\}$ else $\{$int result$2=$ queue.removeItem$()$;System.out.println$($result$2)$;$\}$ break;

case "peek": $\{$int result$3=$ queue.peek$()$;System.out.println$($result$3)$; break;$\}$

case "getSize":int result$4=$ queue.getSize$()$;System.out.println$($result$4)$;break;

case "isEmpty":boolean result$5=$ queue.isEmpty$()$;System.out.println$($result$5)$;break;

case "print":queue.print$()$;break;

$\}\}\}$

The logical binary tree like structure.

$//$Input

OPERATION$\_$COUNT$=10$

addItem$(20)$

addItem$(50)$

addItem$(30)$

addItem$(40)$

addItem$(90)$

addItem$(10)$

addItem$(60)$

removeItem$()$

removeItem$()$

print$()$

$//$Output

$90$

$60$

$\{$ size: $5,$ elements: $[$X$,50,40,30,20,10]\}$

The above is size $5,$

$\{$ size: $5,$ elements: $[$X$,40,30,20,10]\}$ is not.