"""simple docstring"""







from queue import Queue
from typing import TYPE_CHECKING, Optional


if TYPE_CHECKING:
	from ..models.auto import AutoTokenizer

class 		UpperCamelCase      :



				def  _lowercase					(self    :				Tuple     ,  _A    :				List[str])   ->     str:
					raise NotImplementedError()






				def  _lowercase					(self    :				List[str])   ->     Dict:
					raise NotImplementedError()







class 		UpperCamelCase      (   lowercase						):



				def __init__(self    :				Any     ,  _A    :				"AutoTokenizer"     ,  _A    :				bool = False     ,  **_A    :				Any)   ->     Dict:
					__snake_case      :							Union[str, Any]						=			tokenizer
					__snake_case      :							Dict						=			skip_prompt
					__snake_case      :							Union[str, Any]						=			decode_kwargs

					# variables used in the streaming process
					__snake_case      :							Optional[int]						=			[]
					__snake_case      :							str						=			0
					__snake_case      :							Any						=			True



				def  _lowercase					(self    :				Any     ,  _A    :				str)   ->     List[str]:
					if len(value.shape) > 1 and value.shape[0] > 1:
						raise ValueError('TextStreamer only supports batch size 1')
					elif len(value.shape) > 1:
						__snake_case      :							int						=			value[0]

					if self.skip_prompt and self.next_tokens_are_prompt:
						__snake_case      :							Union[str, Any]						=			False
						return

					# Add the new token to the cache and decodes the entire thing.
					self.token_cache.extend(value.tolist())
					__snake_case      :							str						=			self.tokenizer.decode(self.token_cache     ,  **self.decode_kwargs)

					# After the symbol for a new line, we flush the cache.
					if text.endswith('\n'):
						__snake_case      :							Optional[int]						=			text[self.print_len :]
						__snake_case      :							Any						=			[]
						__snake_case      :							List[Any]						=			0
					# If the last token is a CJK character, we print the characters.
					elif len(_A) > 0 and self._is_chinese_char(ord(text[-1])):
						__snake_case      :							List[Any]						=			text[self.print_len :]
						self.print_len += len(_A)
					# Otherwise, prints until the last space char (simple heuristic to avoid printing incomplete words,
					# which may change with the subsequent token -- there are probably smarter ways to do this!)
					else:
						__snake_case      :							Dict						=			text[self.print_len : text.rfind(' ') + 1]
						self.print_len += len(_A)

					self.on_finalized_text(_A)



				def  _lowercase					(self    :				Any)   ->     List[str]:
					# Flush the cache, if it exists
					if len(self.token_cache) > 0:
						__snake_case      :							Optional[Any]						=			self.tokenizer.decode(self.token_cache     ,  **self.decode_kwargs)
						__snake_case      :							List[Any]						=			text[self.print_len :]
						__snake_case      :							Tuple						=			[]
						__snake_case      :							int						=			0
					else:
						__snake_case      :							int						=			''

					__snake_case      :							Optional[int]						=			True
					self.on_finalized_text(_A     ,  stream_end=_A)



				def  _lowercase					(self    :				Dict     ,  _A    :				str     ,  _A    :				bool = False)   ->     Dict:
					print(_A     ,  flush=_A     ,  end='' if not stream_end else None)






				def  _lowercase					(self    :				Optional[Any]     ,  _A    :				List[Any])   ->     Tuple:
					# This defines a "chinese character" as anything in the CJK Unicode block:
					#   https://en.wikipedia.org/wiki/CJK_Unified_Ideographs_(Unicode_block)
					#
					# Note that the CJK Unicode block is NOT all Japanese and Korean characters,
					# despite its name. The modern Korean Hangul alphabet is a different block,
					# as is Japanese Hiragana and Katakana. Those alphabets are used to write
					# space-separated words, so they are not treated specially and handled
					# like the all of the other languages.
					if (
					    (cp >= 0x4E00 and cp <= 0x9FFF)
					    or (cp >= 0x3400 and cp <= 0x4DBF)  #
					    or (cp >= 0x20000 and cp <= 0x2A6DF)  #
					    or (cp >= 0x2A700 and cp <= 0x2B73F)  #
					    or (cp >= 0x2B740 and cp <= 0x2B81F)  #
					    or (cp >= 0x2B820 and cp <= 0x2CEAF)  #
					    or (cp >= 0xF900 and cp <= 0xFAFF)
					    or (cp >= 0x2F800 and cp <= 0x2FA1F)  #
					):  #
						return True

					return False







class 		UpperCamelCase      (   lowercase						):



				def __init__(self    :				int     ,  _A    :				"AutoTokenizer"     ,  _A    :				bool = False     ,  _A    :				Optional[float] = None     ,  **_A    :				str)   ->     str:
					super().__init__(_A     ,  _A     ,  **_A)
					__snake_case      :							Dict						=			Queue()
					__snake_case      :							Any						=			None
					__snake_case      :							Union[str, Any]						=			timeout



				def  _lowercase					(self    :				Any     ,  _A    :				str     ,  _A    :				bool = False)   ->     List[str]:
					self.text_queue.put(_A     ,  timeout=self.timeout)
					if stream_end:
						self.text_queue.put(self.stop_signal     ,  timeout=self.timeout)



				def __iter__(self    :				Union[str, Any])   ->     Dict:
					return self






				def  _lowercase					(self    :				Union[str, Any])   ->     str:
					__snake_case      :							str						=			self.text_queue.get(timeout=self.timeout)
					if value == self.stop_signal:
						raise StopIteration()
					else:
						return value






"""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() = }''')





