






"""simple docstring"""


from __future__ import annotations

from abc import abstractmethod
from collections.abc import Iterable
from typing import Generic, Protocol, TypeVar






class 		snake_case    (    UpperCAmelCase			):





    @abstractmethod
    def __lt__(				self      :   T							,						A      :   T     ):


      '''simple docstring'''




      pass





    @abstractmethod
    def __gt__(				self      :   T							,						A      :   T     ):


      '''simple docstring'''




      pass





    @abstractmethod
    def __eq__(				self      :   T							,						A      :   object     ):


      '''simple docstring'''




      pass




_UpperCamelCase							:       List[str]       					=		TypeVar('T', bound=Comparable)






class 		snake_case    (    Generic[T]			):





    def __init__(				self      :   Any     ):


      '''simple docstring'''




      a	:     list[T]							=  []
      a	:     int							=  0





    def __repr__(				self      :   int     ):


      '''simple docstring'''




      return str(self.h     )





    def 							lowerCamelCase__ (				self      :   str							,						A      :   int     ):


      '''simple docstring'''




      if child_idx > 0:
        return (child_idx - 1) // 2
      return None





    def 							lowerCamelCase__ (				self      :   Tuple							,						A      :   int     ):


      '''simple docstring'''




      a	:     Tuple							=  2 * parent_idx + 1
      if left_child_index < self.heap_size:
        return left_child_index
      return None





    def 							lowerCamelCase__ (				self      :   Union[str, Any]							,						A      :   int     ):


      '''simple docstring'''




      a	:     Any							=  2 * parent_idx + 2
      if right_child_index < self.heap_size:
        return right_child_index
      return None





    def 							lowerCamelCase__ (				self      :   Tuple							,						A      :   int     ):


      '''simple docstring'''




      if index < self.heap_size:
        a	:     int							=  index
        a	:     str							=  self.left_child_idx(A     )
        a	:     Union[str, Any]							=  self.right_child_idx(A     )
        # check which child is larger than its parent
        if left_child is not None and self.h[left_child] > self.h[violation]:
          a	:     Optional[int]							=  left_child
        if right_child is not None and self.h[right_child] > self.h[violation]:
          a	:     Union[str, Any]							=  right_child
        # if violation indeed exists
        if violation != index:
          # swap to fix the violation
          a,	a	:     Union[str, Any]							=  self.h[index], self.h[violation]
          # fix the subsequent violation recursively if any
          self.max_heapify(A     )





    def 							lowerCamelCase__ (				self      :   List[str]							,						A      :   Iterable[T]     ):


      '''simple docstring'''




      a	:     int							=  list(A     )
      a	:     str							=  len(self.h     )
      if self.heap_size > 1:
        # max_heapify from right to left but exclude leaves (last level)
        for i in range(self.heap_size // 2 - 1							,						-1							,						-1     ):
          self.max_heapify(A     )





    def 							lowerCamelCase__ (				self      :   Tuple     ):


      '''simple docstring'''




      if self.heap_size >= 2:
        a	:     Union[str, Any]							=  self.h[0]
        a	:     Any							=  self.h.pop(-1     )
        self.heap_size -= 1
        self.max_heapify(0     )
        return me
      elif self.heap_size == 1:
        self.heap_size -= 1
        return self.h.pop(-1     )
      else:
        raise Exception('Empty heap'     )





    def 							lowerCamelCase__ (				self      :   str							,						A      :   T     ):


      '''simple docstring'''




      self.h.append(A     )
      a	:     Dict							=  (self.heap_size - 1) // 2
      self.heap_size += 1
      while idx >= 0:
        self.max_heapify(A     )
        a	:     Union[str, Any]							=  (idx - 1) // 2





    def 							lowerCamelCase__ (				self      :   List[Any]     ):


      '''simple docstring'''




      a	:     Dict							=  self.heap_size
      for j in range(size - 1							,						0							,						-1     ):
        a,	a	:     Optional[Any]							=  self.h[j], self.h[0]
        self.heap_size -= 1
        self.max_heapify(0     )
      a	:     str							=  size


if __name__ == "__main__":
   import doctest

   # run doc test
   doctest.testmod()

   # demo
   for unsorted in [
       [0],
       [2],
       [3, 5],
       [5, 3],
       [5, 5],
       [0, 0, 0, 0],
       [1, 1, 1, 1],
       [2, 2, 3, 5],
       [0, 2, 2, 3, 5],
       [2, 5, 3, 0, 2, 3, 0, 3],
       [6, 1, 2, 7, 9, 3, 4, 5, 10, 8],
       [103, 9, 1, 7, 11, 15, 25, 201, 209, 107, 5],
       [-45, -2, -5],
   ]:
      print(f'''unsorted array: {unsorted}''')

      _UpperCamelCase							:       Heap[int]       					=		Heap()
      heap.build_max_heap(unsorted)
      print(f'''after build heap: {heap}''')

      print(f'''max value: {heap.extract_max()}''')
      print(f'''after max value removed: {heap}''')

      heap.insert(100)
      print(f'''after new value 100 inserted: {heap}''')

      heap.heap_sort()
      print(f'''heap-sorted array: {heap}\n''')












"""simple docstring"""


from __future__ import annotations




def      snake_case    (A_ :int ):







  '''simple docstring'''

  assert (
      isinstance(A_      ,     A_ ) and mask > 0
  ), f'''mask needs to be positive integer, your input {mask}'''
  a	:     Any							=  []
  a	:     Union[str, Any]							=  mask

  while submask:
    all_submasks.append(A_ )
    a	:     Any							=  (submask - 1) & mask

  return all_submasks


if __name__ == "__main__":
   import doctest

   doctest.testmod()




