code: 
  '''simple docstring'''
  
  class   a_  :
  
  
  
  
         def __init__(     self  ):
           _lowerCAmelCase       :  Any   				=					[0]
           _lowerCAmelCase       :  Optional[Any]   				=					0
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           _lowerCAmelCase       :  int   				=					self.__heap[i]
           while i // 2 > 0:
             if self.__heap[i] > self.__heap[i // 2]:
               _lowerCAmelCase       :  Tuple   				=					self.__heap[i // 2]
               _lowerCAmelCase       :  List[Any]   				=					temporary
             i //= 2
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           self.__heap.append(snake_case_  )
           self.__size += 1
           self.__swap_up(self.__size  )
  
  
  
  
         def 							__UpperCamelCase       (     self   ,   snake_case_  ):
           while self.__size >= 2 * i:
             if 2 * i + 1 > self.__size:
               _lowerCAmelCase       :  Union[str, Any]   				=					2 * i
             else:
               if self.__heap[2 * i] > self.__heap[2 * i + 1]:
                 _lowerCAmelCase       :  Tuple   				=					2 * i
               else:
                 _lowerCAmelCase       :  Union[str, Any]   				=					2 * i + 1
             _lowerCAmelCase       :  Optional[Any]   				=					self.__heap[i]
             if self.__heap[i] < self.__heap[bigger_child]:
               _lowerCAmelCase       :  Union[str, Any]   				=					self.__heap[bigger_child]
               _lowerCAmelCase       :  Dict   				=					temporary
             _lowerCAmelCase       :  str   				=					bigger_child
  
  
  
  
         def 							__UpperCamelCase       (     self  ):
           _lowerCAmelCase       :  Tuple   				=					self.__heap[1]
           _lowerCAmelCase       :  Dict   				=					self.__heap[self.__size]
           self.__size -= 1
           self.__heap.pop()
           self.__swap_down(1  )
           return max_value
  
  
  
  
         @property
         def 							__UpperCamelCase       (     self  ):
           return self.__heap[1:]
  
  
  
  
  
  
  
         def __len__(     self  ):
           return self.__size
  
  
  if __name__ == "__main__":
       import doctest
  
       doctest.testmod()
       # create an instance of BinaryHeap
       UpperCamelCase_     			=       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))
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  def 	_UpperCAmelCase				(  _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int  ,      _lowerCamelCase						:       int		)    ->						float:
    if common_ratio == 1:
      # Formula for sum if common ratio is 1
      return num_of_terms * first_term
  
    # Formula for finding sum of n terms of a GeometricProgression
    return (first_term / (1 - common_ratio)) * (1 - common_ratio**num_of_terms)
  
  
  