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

lowerCAmelCase			:							int     =TypeVar("_T")




class 	__snake_case	( Generic[_T]		):





      '''simple docstring'''






      def __init__(					self     :				List[Any]    ,  _UpperCamelCase     :				List[Any] = None)				->List[Any]:


          """simple docstring"""


          _lowerCamelCase     :		Optional[Any] 						=						list(iterable or [])
          _lowerCamelCase     :		str 						=						[]



      def __len__(					self     :				Dict)				->Union[str, Any]:


          """simple docstring"""


          return len(self._stacka) + len(self._stacka)



      def __repr__(					self     :				Union[str, Any])				->Union[str, Any]:


          """simple docstring"""


          return F"""Queue({tuple(self._stacka[::-1] + self._stacka)})"""



      def 	_SCREAMING_SNAKE_CASE    (					self     :				Dict    ,  _UpperCamelCase     :				int)				->Tuple:


          """simple docstring"""


          self._stacka.append(SCREAMING_SNAKE_CASE_)




      def 	_SCREAMING_SNAKE_CASE    (					self     :				Tuple)				->int:


          """simple docstring"""


          _lowerCamelCase     :		Optional[int] 						=						self._stacka.pop
          _lowerCamelCase     :		List[str] 						=						self._stacka.append

          if not self._stacka:
              while self._stacka:
                  stacka_append(stacka_pop())

          if not self._stacka:
              raise IndexError("""Queue is empty""")
          return self._stacka.pop()


if __name__ == "__main__":
    from doctest import testmod

    testmod()





import math







def 						A__  (					__A	):







    '''simple docstring'''
    assert isinstance(__A   , __A	) and (
        number >= 0
    ), "'number' must been an int and positive"

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

    _lowerCamelCase     :		List[Any] 						=						range(3   , int(math.sqrt(__A	) + 1	)   , 2	)
    return not any(not number % i for i in odd_numbers	)







def 						A__  (					__A   , __A=1   , **__A	):







    '''simple docstring'''
    _lowerCamelCase     :		Dict 						=						factor * value
    _lowerCamelCase     :		str 						=						value

    while not is_prime(__A	):
        value += 1 if not ("desc" in kwargs and kwargs["desc"] is True) else -1

    if value == first_value_val:
        return next_prime(value + 1   , **__A	)
    return value




