
from __future__ import annotations

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






class 						UpperCAmelCase	(		_a				):



   @abstractmethod
   def __lt__(self	:      T					,		snake_case__	:      T				)	->			bool:


          '''simple docstring'''


          pass



   @abstractmethod
   def __gt__(self	:      T					,		snake_case__	:      T				)	->			bool:


          '''simple docstring'''


          pass



   @abstractmethod
   def __eq__(self	:      T					,		snake_case__	:      object				)	->			bool:


          '''simple docstring'''


          pass



__lowerCamelCase     :   List[Any]							= TypeVar("""T""", bound=Comparable)






class 						UpperCAmelCase	(		Generic[T]				):



   def __init__(self	:      List[str]				)	->			None:


          '''simple docstring'''


          snake_case :     List[str]           =   []
          snake_case :     List[Any]           =   0



   def __repr__(self	:      Tuple				)	->			str:


          '''simple docstring'''


          return str(self.h				)



   def        _SCREAMING_SNAKE_CASE     (self	:      Any					,		snake_case__	:      int				)	->			int | None:


          '''simple docstring'''


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



   def        _SCREAMING_SNAKE_CASE     (self	:      List[str]					,		snake_case__	:      int				)	->			int | None:


          '''simple docstring'''


          snake_case :     Optional[Any]           =   2 * parent_idx + 1
          if left_child_index < self.heap_size:
                 return left_child_index
          return None



   def        _SCREAMING_SNAKE_CASE     (self	:      Tuple					,		snake_case__	:      int				)	->			int | None:


          '''simple docstring'''


          snake_case :     List[Any]           =   2 * parent_idx + 2
          if right_child_index < self.heap_size:
                 return right_child_index
          return None



   def        _SCREAMING_SNAKE_CASE     (self	:      str					,		snake_case__	:      int				)	->			None:


          '''simple docstring'''


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



   def        _SCREAMING_SNAKE_CASE     (self	:      int					,		snake_case__	:      Iterable[T]				)	->			None:


          '''simple docstring'''


          snake_case :     Dict           =   list(snake_case__				)
          snake_case :     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(snake_case__				)



   def        _SCREAMING_SNAKE_CASE     (self	:      Any				)	->			T:


          '''simple docstring'''


          if self.heap_size >= 2:
                 snake_case :     str           =   self.h[0]
                 snake_case :     Tuple           =   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        _SCREAMING_SNAKE_CASE     (self	:      Dict					,		snake_case__	:      T				)	->			None:


          '''simple docstring'''


          self.h.append(snake_case__				)
          snake_case :     int           =   (self.heap_size - 1) // 2
          self.heap_size += 1
          while idx >= 0:
                 self.max_heapify(snake_case__				)
                 snake_case :     int           =   (idx - 1) // 2



   def        _SCREAMING_SNAKE_CASE     (self	:      int				)	->			None:


          '''simple docstring'''


          snake_case :     Any           =   self.heap_size
          for j in range(size - 1					,		0					,		-1				):
                 snake_case       ,      snake_case :     Union[str, Any]           =   self.h[j], self.h[0]
                 self.heap_size -= 1
                 self.max_heapify(0				)
          snake_case :     Dict           =   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],
       [1_03, 9, 1, 7, 11, 15, 25, 2_01, 2_09, 1_07, 5],
       [-45, -2, -5],
   ]:
      print(F'unsorted array: {unsorted}')

      __lowerCamelCase     :   List[Any]							= 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(1_00)
      print(F'after new value 100 inserted: {heap}')

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







def     UpperCamelCase      (					__lowerCamelCase  :				int = 998001					):
       snake_case :     Optional[Any]           =   0
       for i in range(999       ,      99       ,      -1					):  # 3 digit numbers range from 999 down to 100
              for j in range(999       ,      99       ,      -1					):
                     snake_case :     Tuple           =   str(i * j					)
                     if product_string == product_string[::-1] and i * j < n:
                            snake_case :     str           =   max(__lowerCamelCase       ,      i * j					)
       return answer


if __name__ == "__main__":
   print(F'{solution() = }')





