



from ..utils import DummyObject, requires_backends




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Any     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Dict      ,		**_A   :  Any):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Union[str, Any]      ,		*_A   :  str      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[Any]     =    ['vision']







					def __init__(							self   :  Optional[int]      ,		*_A   :  Any      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[str]     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  List[str]      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Dict      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[Any]     =    ['vision']







					def __init__(							self   :  str      ,		*_A   :  int      ,		**_A   :  Optional[int]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  Union[str, Any]      ,		*_A   :  int      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[str]     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Union[str, Any]      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Tuple      ,		**_A   :  Any):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Union[str, Any]      ,		*_A   :  Dict      ,		**_A   :  Optional[int]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Tuple      ,		*_A   :  List[str]      ,		**_A   :  str):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Any     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Dict      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[str]     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Tuple      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  str      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[Any]     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Tuple      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Dict      ,		**_A   :  Dict):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Optional[int]      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Union[str, Any]      ,		*_A   :  Optional[Any]      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[int]     =    ['vision']







					def __init__(							self   :  int      ,		*_A   :  int      ,		**_A   :  Dict):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Any      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Dict      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Optional[int]      ,		**_A   :  Dict):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[str]     =    ['vision']







					def __init__(							self   :  Union[str, Any]      ,		*_A   :  List[str]      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[Any]     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  int      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     int     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  List[str]      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Union[str, Any]      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[int]     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Optional[int]      ,		**_A   :  Dict):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     int     =    ['vision']







					def __init__(							self   :  str      ,		*_A   :  Tuple      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Union[str, Any]      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  List[Any]      ,		**_A   :  Optional[int]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Optional[Any]      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     int     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  str      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Union[str, Any]      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Union[str, Any]      ,		**_A   :  Any):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     int     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Optional[Any]      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Union[str, Any]      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Optional[int]      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  int      ,		*_A   :  int      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[Any]     =    ['vision']







					def __init__(							self   :  Optional[int]      ,		*_A   :  int      ,		**_A   :  Any):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Tuple      ,		*_A   :  List[str]      ,		**_A   :  Any):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Tuple      ,		*_A   :  List[Any]      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  int      ,		*_A   :  Tuple      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Tuple      ,		**_A   :  Union[str, Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[str]     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Optional[int]      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[int]     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Tuple      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Union[str, Any]      ,		*_A   :  Any      ,		**_A   :  Dict):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     int     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  int      ,		**_A   :  str):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  int      ,		**_A   :  Optional[int]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[Any]     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Optional[Any]      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Any     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  int      ,		**_A   :  Dict):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[Any]     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Any      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[str]     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Optional[Any]      ,		**_A   :  str):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Optional[int]      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[int]     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Union[str, Any]      ,		**_A   :  Optional[int]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Any     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Optional[Any]      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[int]     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Optional[int]      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[int]     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Dict      ,		**_A   :  Optional[int]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  str      ,		*_A   :  List[Any]      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Dict      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Union[str, Any]      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[Any]     =    ['vision']







					def __init__(							self   :  str      ,		*_A   :  Any      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  Tuple      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Any     =    ['vision']







					def __init__(							self   :  Dict      ,		*_A   :  Dict      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Any      ,		*_A   :  Union[str, Any]      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  List[str]      ,		*_A   :  Union[str, Any]      ,		**_A   :  List[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     str     =    ['vision']







					def __init__(							self   :  str      ,		*_A   :  Dict      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Optional[Any]     =    ['vision']







					def __init__(							self   :  Optional[int]      ,		*_A   :  int      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Tuple     =    ['vision']







					def __init__(							self   :  int      ,		*_A   :  Dict      ,		**_A   :  str):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  Union[str, Any]      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Optional[int]      ,		*_A   :  Optional[Any]      ,		**_A   :  List[str]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Union[str, Any]     =    ['vision']







					def __init__(							self   :  Optional[int]      ,		*_A   :  Optional[Any]      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     int     =    ['vision']







					def __init__(							self   :  Optional[Any]      ,		*_A   :  str      ,		**_A   :  int):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     List[Any]     =    ['vision']







					def __init__(							self   :  List[Any]      ,		*_A   :  List[Any]      ,		**_A   :  Optional[Any]):
											requires_backends(self      ,		["vision"])




class 				lowerCAmelCase__	(						metaclass=UpperCamelCase    ):
					__A  :     Dict     =    ['vision']







					def __init__(							self   :  Optional[int]      ,		*_A   :  Optional[Any]      ,		**_A   :  Tuple):
											requires_backends(self      ,		["vision"])




from itertools import compress, repeat
from math import ceil, sqrt
def 						snake_case__							(       __lowercase							)		->		list[int]:







						"""simple docstring"""

						if num <= 2:
												return []
						if num == 3:
												return [2]

						# Odd sieve for numbers in range [3, num - 1]
						A__						:				Dict         =			bytearray(b"\x01"							) * ((num >> 1) - 1)

						for i in range(3				,  int(sqrt(__lowercase							)							) + 1				,  2							):
												if sieve[(i >> 1) - 1]:
																		A__						:				int         =			i**2
																		A__						:				List[str]         =			repeat(
																		    0				,  ceil((num - i_squared) / (i << 1)							)							)

						return [2] + list(compress(range(3				,  __lowercase				,  2							)				,  __lowercase							)							)


if __name__ == "__main__":
		import doctest

		doctest.testmod()