
from typing import List

from .keymap import KEYMAP, get_character

def      A (       A_							:					str       ):

						def decorator(A_							:					int       ):
												snake_case       :     Dict =    getattr(A_    ,							'''handle_key'''    ,							[]       )
												handle += [key]
												setattr(A_    ,							'''handle_key'''    ,							A_       )
												return func

						return decorator

def      A (       *A_							:					List[str]       ):

						def decorator(A_							:					int       ):
												snake_case       :     List[Any] =    getattr(A_    ,							'''handle_key'''    ,							[]       )
												handle += keys
												setattr(A_    ,							'''handle_key'''    ,							A_       )
												return func

						return decorator

class 						a   (				__magic_name__    ):




				def __new__(							cls	:				Dict,    SCREAMING_SNAKE_CASE_	:				Any,    SCREAMING_SNAKE_CASE_	:				int,    SCREAMING_SNAKE_CASE_	:				List[Any]      ):
										snake_case       :     Tuple =    super().__new__(cls,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_,    SCREAMING_SNAKE_CASE_      )
										if not hasattr(SCREAMING_SNAKE_CASE_,    '''key_handler'''      ):
																setattr(SCREAMING_SNAKE_CASE_,    '''key_handler''',    {}      )
										setattr(SCREAMING_SNAKE_CASE_,    '''handle_input''',    KeyHandler.handle_input      )

										for value in attrs.values():
																snake_case       :     List[str] =    getattr(SCREAMING_SNAKE_CASE_,    '''handle_key''',    []      )
																for key in handled_keys:
																						snake_case       :     int =    value
										return new_cls




				@staticmethod
				def 	__snake_case							(							cls	:				List[Any]      ):
										snake_case       :     Tuple =    get_character()
										if char != KEYMAP["undefined"]:
																snake_case       :     Any =    ord(SCREAMING_SNAKE_CASE_      )
										snake_case       :     int =    cls.key_handler.get(SCREAMING_SNAKE_CASE_      )
										if handler:
																snake_case       :     Dict =    char
																return handler(cls      )
										else:
																return None




def      A (       cls							:					int       ):
						return KeyHandler(cls.__name__    ,							cls.__bases__    ,							cls.__dict__.copy()       )



'''simple docstring'''





from __future__ import annotations

import math

def      A (       A_							:					int       ):

						if num <= 0:
												snake_case       :     List[Any] =    F"""{num}: Invalid input, please enter a positive integer."""
												raise ValueError(A_       )

						snake_case       :     Optional[Any] =    [True] * (num + 1)
						snake_case       :     List[str] =    []
						snake_case       :     List[Any] =    2
						snake_case       :     str =    int(math.sqrt(A_       )       )

						while start <= end:
												# If start is a prime
												if sieve[start] is True:
																		prime.append(A_       )

																		# Set multiples of start be False
																		for i in range(start * start    ,							num + 1    ,							A_       ):
																								if sieve[i] is True:
																														snake_case       :     int =    False

												start += 1

						for j in range(end + 1    ,							num + 1       ):
												if sieve[j] is True:
																		prime.append(A_       )

						return prime


if __name__ == "__main__":
						print(prime_sieve(int(input("Enter a positive integer: ").strip())))

