


from __future__ import annotations

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

_lowercase       :      Union[str, Any]	=	TypeVar("T")






class       _UpperCamelCase    (					Generic[T]				):

    """simple docstring"""







    def __init__(						self				,   a__   )	->				str:
     A								=				data
     A								=				None

    def __str__(						self   )	->				str:
     return f'{self.data}'






class       _UpperCamelCase    (					Generic[T]				):

    """simple docstring"""







    def __init__(						self   )	->				None:
     A								=				None

    def __iter__(						self   )	->				Iterator[T]:
     A								=				self.top
     while node:
      yield node.data
      A								=				node.next

    def __str__(						self   )	->				str:
     return "->".join([str(a__   ) for item in self]   )

    def __len__(						self   )	->				int:
     return len(tuple(iter(self   )   )   )

    def      _UpperCAmelCase					(						self   )	->				bool:
     return self.top is None

    def      _UpperCAmelCase					(						self				,   a__   )	->				None:
     A								=				Node(a__   )
     if not self.is_empty():
      A								=				self.top
     A								=				node

    def      _UpperCAmelCase					(						self   )	->				T:
     if self.is_empty():
      raise IndexError("""pop from empty stack"""   )
     assert isinstance(self.top				,   a__   )
     A								=				self.top
     A								=				self.top.next
     return pop_node.data

    def      _UpperCAmelCase					(						self   )	->				T:
     if self.is_empty():
      raise IndexError("""peek from empty stack"""   )

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

    def      _UpperCAmelCase					(						self   )	->				None:
     A								=				None


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

    testmod()







def   _lowerCAmelCase				(   UpperCamelCase__:     int						) ->   list[int]:





	"""simple docstring"""







	if num <= 0:
		raise ValueError("""Input must be a positive integer"""						)

	A								=				[True] * (num + 1)

	A								=				2
	while p * p <= num:
		if primes[p]:
			for i in range(p * p							,					num + 1							,					UpperCamelCase__						):
				A								=				False
		p += 1

	return [prime for prime in range(2							,					num + 1						) if primes[prime]]


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				_lowercase       :      Tuple	=	int(input("Enter a positive integer: ").strip())
				print(prime_sieve_eratosthenes(user_num))



