"""simple docstring"""







import json
import os
from typing import Optional, Tuple

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


_a					:					str=			logging.get_logger(__name__)

_a					:					Optional[int]=			{"vocab_file": "vocab.json"}

_a					:					str=			{
    "vocab_file": {
        "mgp-str": "https://huggingface.co/alibaba-damo/mgp-str-base/blob/main/vocab.json",
    }
}

_a					:					Dict=			{"mgp-str": 27}

class 		UpperCamelCase      (   lowercase						):
				UpperCAmelCase    :				Tuple   =		VOCAB_FILES_NAMES
				UpperCAmelCase    :				Union[str, Any]   =		PRETRAINED_VOCAB_FILES_MAP
				UpperCAmelCase    :				List[str]   =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES



				def __init__(self    :				Union[str, Any]     ,  _A    :				int     ,  _A    :				List[str]="[GO]"     ,  _A    :				Union[str, Any]="[GO]"     ,  _A    :				Dict="[s]"     ,  _A    :				List[str]="[GO]"     ,  **_A    :				Any)   ->     str:
					super().__init__(
					    unk_token=_A     ,  bos_token=_A     ,  eos_token=_A     ,  pad_token=_A     ,  **_A     ,  )

					with open(_A     ,  encoding='utf-8') as vocab_handle:
						__snake_case      :							Optional[int]						=			json.load(_A)
					__snake_case      :							Union[str, Any]						=			{v: k for k, v in self.vocab.items()}



				@property
				def  _lowercase					(self    :				Any)   ->     Dict:
					return len(self.vocab)



				def  _lowercase					(self    :				Tuple)   ->     Optional[Any]:
					return dict(self.vocab     ,  **self.added_tokens_encoder)



				def  _lowercase					(self    :				Dict     ,  _A    :				List[str])   ->     Optional[Any]:
					__snake_case      :							Optional[Any]						=			[]
					for s in text:
						char_tokens.extend(_A)
					return char_tokens



				def  _lowercase					(self    :				Tuple     ,  _A    :				Dict)   ->     Optional[Any]:
					return self.vocab.get(_A     ,  self.vocab.get(self.unk_token))



				def  _lowercase					(self    :				Tuple     ,  _A    :				Tuple)   ->     str:
					return self.decoder.get(_A)






				def  _lowercase					(self    :				str     ,  _A    :				str     ,  _A    :				Optional[str] = None)   ->     Tuple[str]:
					if not os.path.isdir(_A):
						logger.error('Vocabulary path ({}) should be a directory'.format(_A))
						return
					__snake_case      :							Optional[Any]						=			os.path.join(
					    _A     ,  (filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'])

					with open(_A     ,  'w'     ,  encoding='utf-8') as f:
						f.write(json.dumps(self.vocab     ,  indent=2     ,  sort_keys=_A     ,  ensure_ascii=_A) + '\n')

					return (vocab_file,)






"""simple docstring"""







from __future__ import annotations

import math
def   __UpperCAmelCase    (   UpperCAmelCase_   :    int  )							->      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(UpperCAmelCase_  ) + 1  )      ,							6  ):
		if number % i == 0 or number % (i + 2) == 0:
			return False
	return True


_a					:					Any=			[num for num in range(3, 100_001, 2) if not is_prime(num)]
def   __UpperCAmelCase    (   UpperCAmelCase_   :    int  )							->      list[int]:

	'''simple docstring'''





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

	__snake_case      :							int						=			[]
	for num in range(len(UpperCAmelCase_  )  ):
		__snake_case      :							List[str]						=			0
		while 2 * i * i <= odd_composites[num]:
			__snake_case      :							List[Any]						=			odd_composites[num] - 2 * i * i
			if is_prime(UpperCAmelCase_  ):
				break
			i += 1
		else:
			list_nums.append(odd_composites[num]  )
			if len(UpperCAmelCase_  ) == n:
				return list_nums

	return []
def   __UpperCAmelCase    (   )							->      int:

	'''simple docstring'''





	return compute_nums(1  )[0]


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





