

from __future__ import annotations

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

__UpperCAmelCase								=			TypeVar("""T""")



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






  def __init__(      self			:   str	,							lowerCAmelCase			:   T   )							->     List[Any]:






     """simple docstring"""







     __lowerCAmelCase  :      Union[str, Any]    =						data
     __lowerCAmelCase  :      Node[T] | None    =						None







  def __str__(      self			:   Optional[int]   )							->     str:






     """simple docstring"""







     return f'''{self.data}'''






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






  def __init__(      self			:   List[str]   )							->     None:






     """simple docstring"""







     __lowerCAmelCase  :      Node[T] | None    =						None







  def __iter__(      self			:   Any   )							->     Iterator[T]:






     """simple docstring"""







     __lowerCAmelCase  :      Union[str, Any]    =						self.top
     while node:
        yield node.data
        __lowerCAmelCase  :      Tuple    =						node.next







  def __str__(      self			:   int   )							->     str:






     """simple docstring"""







     return "->".join([str(lowerCAmelCase   ) for item in self]   )







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






     """simple docstring"""







     return len(tuple(iter(self   )   )   )







  def 	SCREAMING_SNAKE_CASE   (      self			:   Any   )							->     bool:






     """simple docstring"""







     return self.top is None







  def 	SCREAMING_SNAKE_CASE   (      self			:   int	,							lowerCAmelCase			:   T   )							->     None:






     """simple docstring"""







     __lowerCAmelCase  :      Dict    =						Node(lowerCAmelCase   )
     if not self.is_empty():
        __lowerCAmelCase  :      str    =						self.top
     __lowerCAmelCase  :      Any    =						node







  def 	SCREAMING_SNAKE_CASE   (      self			:   List[str]   )							->     T:






     """simple docstring"""







     if self.is_empty():
        raise IndexError("""pop from empty stack"""   )
     assert isinstance(self.top	,							lowerCAmelCase   )
     __lowerCAmelCase  :      Union[str, Any]    =						self.top
     __lowerCAmelCase  :      Any    =						self.top.next
     return pop_node.data







  def 	SCREAMING_SNAKE_CASE   (      self			:   str   )							->     T:






     """simple docstring"""







     if self.is_empty():
        raise IndexError("""peek from empty stack"""   )

     assert self.top is not None
     return self.top.data







  def 	SCREAMING_SNAKE_CASE   (      self			:   List[str]   )							->     None:






     """simple docstring"""







     __lowerCAmelCase  :      Any    =						None


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())


