





import math
def      _A       (		SCREAMING_SNAKE_CASE     :   int						):





  """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
def      _A       (		SCREAMING_SNAKE_CASE     :   int = 10_001						):





  """simple docstring"""



  try:
    a__	:					Optional[int]										=int(SCREAMING_SNAKE_CASE						)
  except (TypeError, ValueError):
    raise TypeError("Parameter nth must be int or castable to int."						) from None
  if nth <= 0:
    raise ValueError("Parameter nth must be greater than or equal to one."						)
  a__	:					list[int]										=[]
  a__	:					int										=2
  while len(SCREAMING_SNAKE_CASE						) < nth:
    if is_prime(SCREAMING_SNAKE_CASE						):
      primes.append(SCREAMING_SNAKE_CASE						)
      num += 1
    else:
      num += 1
  return primes[len(SCREAMING_SNAKE_CASE						) - 1]


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










from typing import Dict

from .base import GenericTensor, Pipeline






class   _lowerCamelCase (					UpperCamelCase			):




       """simple docstring"""



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE=None				,       _SCREAMING_SNAKE_CASE=None				,       _SCREAMING_SNAKE_CASE=None				,       **_SCREAMING_SNAKE_CASE		)->List[Any]:




         '''simple docstring'''





         if tokenize_kwargs is None:
           A_      :				Optional[int]		     =					{}

         if truncation is not None:
           if "truncation" in tokenize_kwargs:
             raise ValueError(
                 '''truncation parameter defined twice (given as keyword argument as well as in tokenize_kwargs)'''		)
           A_      :				List[str]		     =					truncation

         A_      :				str		     =					tokenize_kwargs

         A_      :				Optional[Any]		     =					{}
         if return_tensors is not None:
           A_      :				Union[str, Any]		     =					return_tensors

         return preprocess_params, {}, postprocess_params



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)->Dict[str, GenericTensor]:




         '''simple docstring'''





         A_      :				str		     =					self.framework
         A_      :				Any		     =					self.tokenizer(_SCREAMING_SNAKE_CASE				,       return_tensors=_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)
         return model_inputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE		)->Optional[Any]:




         '''simple docstring'''





         A_      :				Optional[int]		     =					self.model(**_SCREAMING_SNAKE_CASE		)
         return model_outputs



       def        _snake_case       (      self				,       _SCREAMING_SNAKE_CASE				,       _SCREAMING_SNAKE_CASE=False		)->List[Any]:




         '''simple docstring'''





         if return_tensors:
           return model_outputs[0]
         if self.framework == "pt":
           return model_outputs[0].tolist()
         elif self.framework == "tf":
           return model_outputs[0].numpy().tolist()







       def __call__(      self				,       *_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)->Union[str, Any]:




         '''simple docstring'''





         return super().__call__(*_SCREAMING_SNAKE_CASE				,       **_SCREAMING_SNAKE_CASE		)




