




'''simple docstring'''

from __future__ import annotations

import math


def 						__magic_name__       (      __UpperCAmelCase      )						->   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    :							List[str]										=    [num for num in range(3, 10_0001, 2) if not is_prime(num)]


def 						__magic_name__       (      __UpperCAmelCase      )						->   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_		     =							[]
					for num in range(len(__UpperCAmelCase      )      ):
										snake_case_		     =							0
										while 2 * i * i <= odd_composites[num]:
															snake_case_		     =							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 						__magic_name__       (      )						->   int:

					'''simple docstring'''

					return compute_nums(1      )[0]


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







'''simple docstring'''

import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin






@require_tokenizers
class 		a							(  _lowerCamelCase  ,	unittest.TestCase	):
				snake_case_           =						CLIPTokenizer
				snake_case_           =						CLIPTokenizerFast
				snake_case_           =						True
				snake_case_           =						{}
				snake_case_           =						False


				def     A_					(						self       :   List[Any]   ):
									super().setUp()

									# fmt: off
									snake_case_		     =							['''l''', '''o''', '''w''', '''e''', '''r''', '''s''', '''t''', '''i''', '''d''', '''n''', '''lo''', '''l</w>''', '''w</w>''', '''r</w>''', '''t</w>''', '''low</w>''', '''er</w>''', '''lowest</w>''', '''newer</w>''', '''wider''', '''<unk>''', '''<|startoftext|>''', '''<|endoftext|>''']
									# fmt: on
									snake_case_		     =							dict(zip(lowercase_			,							range(len(lowercase_   )   )   )   )
									snake_case_		     =							['''#version: 0.2''', '''l o''', '''lo w</w>''', '''e r</w>''']
									snake_case_		     =							{'''unk_token''': '''<unk>'''}

									snake_case_		     =							os.path.join(self.tmpdirname			,							VOCAB_FILES_NAMES['''vocab_file''']   )
									snake_case_		     =							os.path.join(self.tmpdirname			,							VOCAB_FILES_NAMES['''merges_file''']   )
									with open(self.vocab_file			,							'''w'''			,							encoding='''utf-8'''   ) as fp:
														fp.write(json.dumps(lowercase_   ) + '''\n'''   )
									with open(self.merges_file			,							'''w'''			,							encoding='''utf-8'''   ) as fp:
														fp.write('''\n'''.join(lowercase_   )   )


				def     A_					(						self       :   Tuple			,							**lowercase_       :   Tuple   ):
									kwargs.update(self.special_tokens_map   )
									return CLIPTokenizer.from_pretrained(self.tmpdirname			,							**lowercase_   )


				def     A_					(						self       :   List[str]			,							**lowercase_       :   Dict   ):
									kwargs.update(self.special_tokens_map   )
									return CLIPTokenizerFast.from_pretrained(self.tmpdirname			,							**lowercase_   )


				def     A_					(						self       :   Optional[int]			,							lowercase_       :   Optional[int]   ):
									snake_case_		     =							'''lower newer'''
									snake_case_		     =							'''lower newer'''
									return input_text, output_text


				def     A_					(						self       :   Optional[int]   ):
									snake_case_		     =							CLIPTokenizer(self.vocab_file			,							self.merges_file			,							**self.special_tokens_map   )
									snake_case_		     =							'''lower newer'''
									snake_case_		     =							['''lo''', '''w''', '''er</w>''', '''n''', '''e''', '''w''', '''er</w>''']
									snake_case_		     =							tokenizer.tokenize(lowercase_   )
									self.assertListEqual(lowercase_			,							lowercase_   )

									snake_case_		     =							tokens + [tokenizer.unk_token]
									snake_case_		     =							[10, 2, 16, 9, 3, 2, 16, 20]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase_   )			,							lowercase_   )


				@require_ftfy
				def     A_					(						self       :   Optional[Any]   ):
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
																			snake_case_		     =							self.tokenizer_class.from_pretrained(lowercase_			,							**lowercase_   )
																			snake_case_		     =							self.rust_tokenizer_class.from_pretrained(lowercase_			,							**lowercase_   )

																			snake_case_		     =							'''A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'''
																			snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																			snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																			self.assertListEqual(lowercase_			,							lowercase_   )

																			# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
																			# with Tilde) encoded in 2 different ways
																			snake_case_		     =							'''xa\u0303y''' + ''' ''' + '''x\xe3y'''
																			snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																			snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																			self.assertListEqual(lowercase_			,							lowercase_   )

																			# Test that the tokenization is identical on unicode of space type
																			snake_case_		     =							[
																			    '''\u0009''',  # (horizontal tab, '\t')
																			    '''\u000B''',  # (vertical tab)
																			    '''\u000C''',  # (form feed)
																			    '''\u0020''',  # (space, ' ')
																			    '''\u200E''',  # (left-to-right mark):w
																			    '''\u200F''',  # (right-to-left mark)
																			]
																			for unicode_seq in spaces_unicodes:
																								snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																								snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																								self.assertListEqual(lowercase_			,							lowercase_   )

																			# Test that the tokenization is identical on unicode of line break type
																			snake_case_		     =							[
																			    '''\u000A''',  # (line feed, '\n')
																			    '''\r\n''',  # (carriage return and line feed, '\r\n')
																			    '''\u000D''',  # (carriage return, '\r')
																			    '''\r''',  # (carriage return, '\r')
																			    '''\u000D''',  # (carriage return, '\r')
																			    '''\u2028''',  # (line separator)
																			    '''\u2029''',  # (paragraph separator)
																			    # "\u0085", # (next line)
																			]

																			# The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
																			# it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
																			# space (and thus into an empty list).

																			for unicode_seq in line_break_unicodes:
																								snake_case_		     =							tokenizer_s.tokenize(lowercase_   )
																								snake_case_		     =							tokenizer_r.tokenize(lowercase_   )

																								self.assertListEqual(lowercase_			,							lowercase_   )


				def     A_					(						self       :   List[str]   ):
									# Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
														with self.subTest(F"{tokenizer.__class__.__name__} ({pretrained_name})"   ):
																			snake_case_		     =							'''hello'''  # `hello` is a token in the vocabulary of `pretrained_name`
																			snake_case_		     =							F"{text_of_1_token} {text_of_1_token}"

																			snake_case_		     =							self.rust_tokenizer_class.from_pretrained(
																			    lowercase_			,							use_fast=lowercase_			,							)
																			snake_case_		     =							tokenizer_r(lowercase_			,							return_offsets_mapping=lowercase_			,							add_special_tokens=lowercase_   )
																			self.assertEqual(encoding.offset_mapping[0]			,							(0, len(lowercase_   ))   )
																			self.assertEqual(
																			    encoding.offset_mapping[1]			,							(len(lowercase_   ) + 1, len(lowercase_   ) + 1 + len(lowercase_   ))			,							)

																			snake_case_		     =							F" {text}"

																			snake_case_		     =							self.rust_tokenizer_class.from_pretrained(
																			    lowercase_			,							use_fast=lowercase_			,							)
																			snake_case_		     =							tokenizer_r(lowercase_			,							return_offsets_mapping=lowercase_			,							add_special_tokens=lowercase_   )
																			self.assertEqual(encoding.offset_mapping[0]			,							(1, 1 + len(lowercase_   ))   )
																			self.assertEqual(
																			    encoding.offset_mapping[1]			,							(1 + len(lowercase_   ) + 1, 1 + len(lowercase_   ) + 1 + len(lowercase_   ))			,							)


				def     A_					(						self       :   Optional[Any]   ):
									# Test related to the breaking change introduced in transformers v4.17.0
									# We need to check that an error in raised when the user try to load a previous version of the tokenizer.
									with self.assertRaises(lowercase_   ) as context:
														self.rust_tokenizer_class.from_pretrained('''robot-test/old-clip-tokenizer'''   )

									self.assertTrue(
									    context.exception.args[0].startswith(
									        '''The `backend_tokenizer` provided does not match the expected format.'''   )   )


				@require_ftfy
				def     A_					(						self       :   List[str]   ):
									super().test_tokenization_python_rust_equals()


				def     A_					(						self       :   List[Any]   ):
									# CLIP always lower cases letters
									pass

