class 				a_ :






 '''simple docstring'''






 def __init__(			self					:  Any):







        '''simple docstring'''



        lowerCAmelCase__     	=					[0]
        lowerCAmelCase__     	=					0




 def 		__snake_case						(			self					:  List[str]			,    lowercase__					:  int):







        '''simple docstring'''



        lowerCAmelCase__     	=					self.__heap[i]
        while i // 2 > 0:
               if self.__heap[i] > self.__heap[i // 2]:
                      lowerCAmelCase__     	=					self.__heap[i // 2]
                      lowerCAmelCase__     	=					temporary
               i //= 2




 def 		__snake_case						(			self					:  List[Any]			,    lowercase__					:  int):







        '''simple docstring'''



        self.__heap.append(lowercase__)
        self.__size += 1
        self.__swap_up(self.__size)




 def 		__snake_case						(			self					:  int			,    lowercase__					:  int):







        '''simple docstring'''



        while self.__size >= 2 * i:
               if 2 * i + 1 > self.__size:
                      lowerCAmelCase__     	=					2 * i
               else:
                      if self.__heap[2 * i] > self.__heap[2 * i + 1]:
                             lowerCAmelCase__     	=					2 * i
                      else:
                             lowerCAmelCase__     	=					2 * i + 1
               lowerCAmelCase__     	=					self.__heap[i]
               if self.__heap[i] < self.__heap[bigger_child]:
                      lowerCAmelCase__     	=					self.__heap[bigger_child]
                      lowerCAmelCase__     	=					temporary
               lowerCAmelCase__     	=					bigger_child




 def 		__snake_case						(			self					:  Dict):







        '''simple docstring'''



        lowerCAmelCase__     	=					self.__heap[1]
        lowerCAmelCase__     	=					self.__heap[self.__size]
        self.__size -= 1
        self.__heap.pop()
        self.__swap_down(1)
        return max_value




 @property
 def 		__snake_case						(			self					:  List[str]):







        '''simple docstring'''



        return self.__heap[1:]




 def __len__(			self					:  Tuple):







        '''simple docstring'''



        return self.__size


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    # create an instance of BinaryHeap
    lowerCAmelCase__							= 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        __lowerCAmelCase    (SCREAMING_SNAKE_CASE					)->  int:




      """simple docstring"""

      if number != int(SCREAMING_SNAKE_CASE					):
            raise ValueError('''factorial() only accepts integral values'''					)
      if number < 0:
            raise ValueError('''factorial() not defined for negative values'''					)
      snake_case_       =      1
      for i in range(1					,					number + 1					):
            value *= i
      return value






def        __lowerCAmelCase    (SCREAMING_SNAKE_CASE					)->  int:




      """simple docstring"""

      if not isinstance(SCREAMING_SNAKE_CASE					,					SCREAMING_SNAKE_CASE					):
            raise ValueError('''factorial() only accepts integral values'''					)
      if n < 0:
            raise ValueError('''factorial() not defined for negative values'''					)
      return 1 if n == 0 or n == 1 else n * factorial(n - 1					)


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   UpperCAmelCase			=    int(input("""Enter a positive integer: """).strip() or 0)
   print(f'''factorial{n} is {factorial(n)}''')