





from __future__ import annotations

import math



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     bool:


      '''simple docstring'''


      if 1 < number < 4:
            # 2 and 3 are primes
            return True
      elif number < 2 or number % 2 == 0 or number % 3 == 0:
            # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
            return False

      # All primes number are in format of 6k +/- 1
      for i in range(5				,		int(math.sqrt(_SCREAMING_SNAKE_CASE			) + 1			)				,		6			):
            if number % i == 0 or number % (i + 2) == 0:
                  return False
      return True


SCREAMING_SNAKE_CASE_		     = [num for num in range(3, 1_0_0_0_0_1, 2) if not is_prime(num)]



def      __lowercase     (   _SCREAMING_SNAKE_CASE			)				->     list[int]:


      '''simple docstring'''


      if not isinstance(_SCREAMING_SNAKE_CASE				,		_SCREAMING_SNAKE_CASE			):
            raise ValueError("""n must be an integer"""			)
      if n <= 0:
            raise ValueError("""n must be >= 0"""			)

      SCREAMING_SNAKE_CASE	=		[]
      for num in range(len(_SCREAMING_SNAKE_CASE			)			):
            SCREAMING_SNAKE_CASE	=		0
            while 2 * i * i <= odd_composites[num]:
                  SCREAMING_SNAKE_CASE	=		odd_composites[num] - 2 * i * i
                  if is_prime(_SCREAMING_SNAKE_CASE			):
                        break
                  i += 1
            else:
                  list_nums.append(odd_composites[num]			)
                  if len(_SCREAMING_SNAKE_CASE			) == n:
                        return list_nums

      return []



def      __lowercase     (   )				->     int:


      '''simple docstring'''


      return compute_nums(1			)[0]


if __name__ == "__main__":
      print(F'''{solution() = }''')









from ..utils import DummyObject, requires_backends

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Any )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					Any		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					List[Any] )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					Optional[int] )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					Tuple		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					Any )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					Optional[int]		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Optional[int] )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[str]				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					Optional[Any] )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[str]				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					str )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			int				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Optional[Any] )  ->	int:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[Any]				=    ["sentencepiece"]






     def __init__(							self		:					List[str]		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					int )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					str		,*lowerCamelCase__		:					Union[str, Any]		,**lowerCamelCase__		:					List[str] )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Any				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					Dict		,**lowerCamelCase__		:					List[Any] )  ->	List[str]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Any				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Optional[int] )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Tuple				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					Optional[int] )  ->	Optional[Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[Any]				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					int )  ->	Any:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Tuple				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					Dict )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[Any]				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					Optional[Any] )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			int				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					str )  ->	List[Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					Any		,**lowerCamelCase__		:					Dict )  ->	List[Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			int				=    ["sentencepiece"]






     def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					Any )  ->	int:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					str )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					int		,**lowerCamelCase__		:					Any )  ->	List[str]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Any				=    ["sentencepiece"]






     def __init__(							self		:					Dict		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					str )  ->	int:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			List[str]				=    ["sentencepiece"]






     def __init__(							self		:					Optional[int]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Union[str, Any] )  ->	Tuple:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					List[Any] )  ->	Any:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Optional[Any]				=    ["sentencepiece"]






     def __init__(							self		:					List[str]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					str )  ->	Union[str, Any]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Optional[int]				=    ["sentencepiece"]






     def __init__(							self		:					Optional[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					str )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Tuple				=    ["sentencepiece"]






     def __init__(							self		:					Any		,*lowerCamelCase__		:					Optional[int]		,**lowerCamelCase__		:					Any )  ->	Optional[int]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Dict				=    ["sentencepiece"]






     def __init__(							self		:					Union[str, Any]		,*lowerCamelCase__		:					List[str]		,**lowerCamelCase__		:					List[Any] )  ->	str:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			str				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					str		,**lowerCamelCase__		:					str )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					int		,*lowerCamelCase__		:					List[Any]		,**lowerCamelCase__		:					Optional[int] )  ->	List[str]:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )

class 	UpperCamelCase__				(   metaclass=lowerCAmelCase_     ):



     '''simple docstring'''

     __snake_case					:			Union[str, Any]				=    ["sentencepiece"]






     def __init__(							self		:					List[Any]		,*lowerCamelCase__		:					Tuple		,**lowerCamelCase__		:					Dict )  ->	Dict:




           '''simple docstring'''


           requires_backends(self		,["""sentencepiece"""] )


