
class  snake_case__						:






     """simple docstring"""


     def __init__(	self  :  List[Any] )       ->str:
            snake_case__							:     Tuple            =     [0]
            snake_case__							:     str            =     0






     def        lowercase_       (	self  :  Tuple,			_snake_case  :  int )       ->None:
            snake_case__							:     List[Any]            =     self.__heap[i]
            while i // 2 > 0:
                   if self.__heap[i] > self.__heap[i // 2]:
                          snake_case__							:     int            =     self.__heap[i // 2]
                          snake_case__							:     Any            =     temporary
                   i //= 2






     def        lowercase_       (	self  :  Any,			_snake_case  :  int )       ->None:
            self.__heap.append(_snake_case )
            self.__size += 1
            self.__swap_up(self.__size )






     def        lowercase_       (	self  :  Tuple,			_snake_case  :  int )       ->None:
            while self.__size >= 2 * i:
                   if 2 * i + 1 > self.__size:
                          snake_case__							:     Tuple            =     2 * i
                   else:
                          if self.__heap[2 * i] > self.__heap[2 * i + 1]:
                                 snake_case__							:     Union[str, Any]            =     2 * i
                          else:
                                 snake_case__							:     Tuple            =     2 * i + 1
                   snake_case__							:     Any            =     self.__heap[i]
                   if self.__heap[i] < self.__heap[bigger_child]:
                          snake_case__							:     Union[str, Any]            =     self.__heap[bigger_child]
                          snake_case__							:     Dict            =     temporary
                   snake_case__							:     List[Any]            =     bigger_child






     def        lowercase_       (	self  :  Dict )       ->int:
            snake_case__							:     Optional[Any]            =     self.__heap[1]
            snake_case__							:     Union[str, Any]            =     self.__heap[self.__size]
            self.__size -= 1
            self.__heap.pop()
            self.__swap_down(1 )
            return max_value






     @property
     def        lowercase_       (	self  :  Optional[int] )       ->Optional[Any]:
            return self.__heap[1:]






     def __len__(	self  :  List[Any] )       ->Any:
            return self.__size


if __name__ == "__main__":
 import doctest

 doctest.testmod()
 # create an instance of BinaryHeap
 a_       :Optional[int]				  =				BinaryHeap()
 binary_heap.insert(6)
 binary_heap.insert(10)
 binary_heap.insert(15)
 binary_heap.insert(12)
 # pop root(max-values because it is max heap)
 print(binary_heap.pop())  # 15
 print(binary_heap.pop())  # 12
 # get the list and size after operations
 print(binary_heap.get_list)
 print(len(binary_heap))











def 	lowercase_							(A			:			int		, A			:			int				):
       return (input_a, input_a).count(0				) % 2
def 	lowercase_							():
       assert xor_gate(0		, 0				) == 0
       assert xor_gate(0		, 1				) == 1
       assert xor_gate(1		, 0				) == 1
       assert xor_gate(1		, 1				) == 0


if __name__ == "__main__":
 print(xor_gate(0, 0))
 print(xor_gate(0, 1))






