






from __future__ import annotations

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

__UpperCAmelCase      =				TypeVar("T", bound=bool)
class 	a_(		Generic[T]	):



     """simple docstring"""



     def __init__(		self					:	Tuple  ,  lowerCAmelCase__					:	T)							->	None:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		value
      SCREAMING_SNAKE_CASE				    =		None
      SCREAMING_SNAKE_CASE				    =		None





     @property
     def     __UpperCamelCase						(		self					:	int)							->	T:

      """simple docstring"""
      return self._value





     @staticmethod
     def     __UpperCamelCase						(		lowerCAmelCase__					:	RandomizedHeapNode[T] | None  ,  lowerCAmelCase__					:	RandomizedHeapNode[T] | None)							->	RandomizedHeapNode[T] | None:

      """simple docstring"""
      if not roota:
       return roota

      if not roota:
       return roota

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

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

      SCREAMING_SNAKE_CASE				    =		RandomizedHeapNode.merge(roota.left  ,  lowerCAmelCase__)

      return roota

class 	a_(		Generic[T]	):



     """simple docstring"""



     def __init__(		self					:	Union[str, Any]  ,  lowerCAmelCase__					:	Iterable[T] | None = ())							->	None:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		None

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





     def     __UpperCamelCase						(		self					:	Optional[int]  ,  lowerCAmelCase__					:	T)							->	None:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		RandomizedHeapNode.merge(self._root  ,  RandomizedHeapNode(lowerCAmelCase__))





     def     __UpperCamelCase						(		self					:	Optional[int])							->	T | None:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		self.top()

      if self._root is None:
       return None

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

      return result





     def     __UpperCamelCase						(		self					:	Tuple)							->	T:

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





     def     __UpperCamelCase						(		self					:	Optional[int])							->	None:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		None





     def     __UpperCamelCase						(		self					:	List[str])							->	list[Any]:

      """simple docstring"""
      SCREAMING_SNAKE_CASE				    =		[]
      while self:
       result.append(self.pop())

      return result





     def __bool__(		self					:	Optional[int])							->	bool:

      """simple docstring"""
      return self._root is not None


if __name__ == "__main__":
      import doctest

      doctest.testmod()






import math
def lowerCamelCase_       (			A			:      int						):




      """simple docstring"""

      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5		,					int(math.sqrt(A						) + 1						)		,					6						):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True
def lowerCamelCase_       (			A			:      int = 2_00_00_00						):




      """simple docstring"""
      return sum(num for num in range(3		,					A		,					2						) if is_prime(A						)						) + 2 if n > 2 else 0


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



