





from __future__ import annotations

import random
from collections.abc import Iterable
from typing import Any, Generic, TypeVar

UpperCAmelCase_											=  TypeVar("T", bound=bool)




class  __UpperCamelCase						(       Generic[T]						):





     def __init__(    self							,       _UpperCamelCase				):
        _UpperCAmelCase											=      value
        _UpperCAmelCase											=      None
        _UpperCAmelCase											=      None





     @property
     def 		UpperCamelCase(    self				):
        return self._value





     @staticmethod
     def 		UpperCamelCase(    _UpperCamelCase							,       _UpperCamelCase				):
        if not roota:
           return roota

        if not roota:
           return roota

        if roota.value > roota.value:
           _UpperCAmelCase					,			_UpperCAmelCase											=      roota, roota

        if random.choice([True, False]				):
           _UpperCAmelCase					,			_UpperCAmelCase											=      roota.right, roota.left

        _UpperCAmelCase											=      RandomizedHeapNode.merge(roota.left							,       _UpperCamelCase				)

        return roota




class  __UpperCamelCase						(       Generic[T]						):





     def __init__(    self							,       _UpperCamelCase = ()				):
        _UpperCAmelCase											=      None

        if data:
           for item in data:
              self.insert(_UpperCamelCase				)





     def 		UpperCamelCase(    self							,       _UpperCamelCase				):
        _UpperCAmelCase											=      RandomizedHeapNode.merge(self._root							,       RandomizedHeapNode(_UpperCamelCase				)				)





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      self.top()

        if self._root is None:
           return None

        _UpperCAmelCase											=      RandomizedHeapNode.merge(self._root.left							,       self._root.right				)

        return result





     def 		UpperCamelCase(    self				):
        if not self._root:
           raise IndexError('''Can\'t get top element for the empty heap.'''				)
        return self._root.value





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      None





     def 		UpperCamelCase(    self				):
        _UpperCAmelCase											=      []
        while self:
           result.append(self.pop()				)

        return result





     def __bool__(    self				):
        return self._root is not None


if __name__ == "__main__":
   import doctest

   doctest.testmod()






def     A__					(						SCREAMING_SNAKE_CASE_      :			list	)     ->     bool:






   """simple docstring"""







   if not isinstance(SCREAMING_SNAKE_CASE_							,  SCREAMING_SNAKE_CASE_	):
      raise ValueError('''Input series is not valid, valid series - [1, 2/3, 2]'''	)
   if len(SCREAMING_SNAKE_CASE_	) == 0:
      raise ValueError('''Input list must be a non empty list'''	)
   if len(SCREAMING_SNAKE_CASE_	) == 1 and series[0] != 0:
      return True
   _UpperCAmelCase											=      []
   _UpperCAmelCase											=      len(SCREAMING_SNAKE_CASE_	)
   for i in range(0							,  SCREAMING_SNAKE_CASE_	):
      if series[i] == 0:
         raise ValueError('''Input series cannot have 0 as an element'''	)
      rec_series.append(1 / series[i]	)
   _UpperCAmelCase											=      rec_series[1] - rec_series[0]
   for index in range(2							,  SCREAMING_SNAKE_CASE_	):
      if rec_series[index] - rec_series[index - 1] != common_diff:
         return False
   return True
def     A__					(						SCREAMING_SNAKE_CASE_      :			list	)     ->     float:






   """simple docstring"""







   if not isinstance(SCREAMING_SNAKE_CASE_							,  SCREAMING_SNAKE_CASE_	):
      raise ValueError('''Input series is not valid, valid series - [2, 4, 6]'''	)
   if len(SCREAMING_SNAKE_CASE_	) == 0:
      raise ValueError('''Input list must be a non empty list'''	)
   _UpperCAmelCase											=      0
   for val in series:
      answer += 1 / val
   return len(SCREAMING_SNAKE_CASE_	) / answer


if __name__ == "__main__":
   import doctest

   doctest.testmod()