

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

__UpperCAmelCase								=			TypeVar("""_T""")



class SCREAMING_SNAKE_CASE     (  Generic[_T]			):
  """simple docstring"""






  def __init__(      self			:   int	,							lowerCAmelCase			:   Iterable[_T] | None = None   )							->     Any:






     """simple docstring"""







     __lowerCAmelCase  :      Dict    =						list(iterable or []   )
     __lowerCAmelCase  :      Optional[Any]    =						[]







  def __len__(      self			:   Dict   )							->     List[str]:






     """simple docstring"""







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







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






     """simple docstring"""







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







  def 	SCREAMING_SNAKE_CASE   (      self			:   Union[str, Any]	,							lowerCAmelCase			:   _T   )							->     str:






     """simple docstring"""







     self._stacka.append(_lowercase   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Tuple   )							->     Dict:






     """simple docstring"""







     __lowerCAmelCase  :      int    =						self._stacka.pop
     __lowerCAmelCase  :      Any    =						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()





def      snake_case_				()      ->     List[Any]:
   for n in range(1 ,       1_0_0_0_0_0_0					):
      yield n * (n + 1) // 2





def      snake_case_				(__A					:						Dict					)      ->     Tuple:
   __lowerCAmelCase  :      Optional[int]    =						1
   __lowerCAmelCase  :      Optional[int]    =						2
   while i * i <= n:
      __lowerCAmelCase  :      Optional[int]    =						0
      while n % i == 0:
         n //= i
         multiplicity += 1
      divisors_count *= multiplicity + 1
      i += 1
   if n > 1:
      divisors_count *= 2
   return divisors_count





def      snake_case_				()      ->     Dict:
   return next(i for i in triangle_number_generator() if count_divisors(__A					) > 5_0_0					)


if __name__ == "__main__":
   print(solution())


