



'''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       __magic_name__		(       _UpperCamelCase     ,		unittest.TestCase  ):
							lowerCAmelCase			:       List[str]  							=   CLIPTokenizer
							lowerCAmelCase			:       Union[str, Any]  							=   CLIPTokenizerFast
							lowerCAmelCase			:       Tuple  							=   True
							lowerCAmelCase			:       Optional[Any]  							=   {}
							lowerCAmelCase			:       int  							=   False







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

									# fmt: off
									_a	: List[str]								=				['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
									_a	: List[str]								=				dict(zip(_UpperCAmelCase      ,range(len(_UpperCAmelCase						)						)						)						)
									_a	: int								=				['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>']
									_a	: str								=				{'unk_token': '<unk>'}

									_a	: List[str]								=				os.path.join(self.tmpdirname      ,VOCAB_FILES_NAMES['vocab_file']						)
									_a	: Any								=				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(_UpperCAmelCase						) + '\n'						)
									with open(self.merges_file      ,'w'      ,encoding='utf-8'						) as fp:
											fp.write('\n'.join(_UpperCAmelCase						)						)







							def 				__lowercase     (				self   :			Optional[int]      ,**_UpperCAmelCase   :			List[Any]						):
									kwargs.update(self.special_tokens_map						)
									return CLIPTokenizer.from_pretrained(self.tmpdirname      ,**_UpperCAmelCase						)







							def 				__lowercase     (				self   :			List[Any]      ,**_UpperCAmelCase   :			str						):
									kwargs.update(self.special_tokens_map						)
									return CLIPTokenizerFast.from_pretrained(self.tmpdirname      ,**_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Tuple      ,_UpperCAmelCase   :			Tuple						):
									_a	: Any								=				'lower newer'
									_a	: List[str]								=				'lower newer'
									return input_text, output_text







							def 				__lowercase     (				self   :			Tuple						):
									_a	: int								=				CLIPTokenizer(self.vocab_file      ,self.merges_file      ,**self.special_tokens_map						)
									_a	: Any								=				'lower newer'
									_a	: int								=				['lo', 'w', 'er</w>', 'n', 'e', 'w', 'er</w>']
									_a	: Optional[Any]								=				tokenizer.tokenize(_UpperCAmelCase						)
									self.assertListEqual(_UpperCAmelCase      ,_UpperCAmelCase						)

									_a	: Union[str, Any]								=				tokens + [tokenizer.unk_token]
									_a	: str								=				[10, 2, 16, 9, 3, 2, 16, 20]
									self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase						)      ,_UpperCAmelCase						)







							@require_ftfy
							def 				__lowercase     (				self   :			Optional[Any]						):
									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
											with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""						):
													_a	: Optional[int]								=				self.tokenizer_class.from_pretrained(_UpperCAmelCase      ,**_UpperCAmelCase						)
													_a	: List[str]								=				self.rust_tokenizer_class.from_pretrained(_UpperCAmelCase      ,**_UpperCAmelCase						)

													_a	: int								=				'A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'
													_a	: Optional[Any]								=				tokenizer_s.tokenize(_UpperCAmelCase						)
													_a	: List[Any]								=				tokenizer_r.tokenize(_UpperCAmelCase						)

													self.assertListEqual(_UpperCAmelCase      ,_UpperCAmelCase						)

													# Test that the tokenization is identical on an example containing a character (Latin Small Letter A
													# with Tilde) encoded in 2 different ways
													_a	: Optional[Any]								=				'xa\u0303y' + ' ' + 'x\xe3y'
													_a	: Any								=				tokenizer_s.tokenize(_UpperCAmelCase						)
													_a	: Union[str, Any]								=				tokenizer_r.tokenize(_UpperCAmelCase						)

													self.assertListEqual(_UpperCAmelCase      ,_UpperCAmelCase						)

													# Test that the tokenization is identical on unicode of space type
													_a	: Union[str, Any]								=				[
													    '\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:
															_a	: str								=				tokenizer_s.tokenize(_UpperCAmelCase						)
															_a	: List[Any]								=				tokenizer_r.tokenize(_UpperCAmelCase						)

															self.assertListEqual(_UpperCAmelCase      ,_UpperCAmelCase						)

													# Test that the tokenization is identical on unicode of line break type
													_a	: List[Any]								=				[
													    '\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:
															_a	: str								=				tokenizer_s.tokenize(_UpperCAmelCase						)
															_a	: Tuple								=				tokenizer_r.tokenize(_UpperCAmelCase						)

															self.assertListEqual(_UpperCAmelCase      ,_UpperCAmelCase						)







							def 				__lowercase     (				self   :			Union[str, Any]						):
									# 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})"""						):
													_a	: Union[str, Any]								=				'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
													_a	: Dict								=				F"""{text_of_1_token} {text_of_1_token}"""

													_a	: List[str]								=				self.rust_tokenizer_class.from_pretrained(
													    _UpperCAmelCase      ,use_fast=_UpperCAmelCase      ,)
													_a	: str								=				tokenizer_r(_UpperCAmelCase      ,return_offsets_mapping=_UpperCAmelCase      ,add_special_tokens=_UpperCAmelCase						)
													self.assertEqual(encoding.offset_mapping[0]      ,(0, len(_UpperCAmelCase						))						)
													self.assertEqual(
													    encoding.offset_mapping[1]      ,(len(_UpperCAmelCase						) + 1, len(_UpperCAmelCase						) + 1 + len(_UpperCAmelCase						))      ,)

													_a	: List[str]								=				F""" {text}"""

													_a	: Tuple								=				self.rust_tokenizer_class.from_pretrained(
													    _UpperCAmelCase      ,use_fast=_UpperCAmelCase      ,)
													_a	: List[str]								=				tokenizer_r(_UpperCAmelCase      ,return_offsets_mapping=_UpperCAmelCase      ,add_special_tokens=_UpperCAmelCase						)
													self.assertEqual(encoding.offset_mapping[0]      ,(1, 1 + len(_UpperCAmelCase						))						)
													self.assertEqual(
													    encoding.offset_mapping[1]      ,(1 + len(_UpperCAmelCase						) + 1, 1 + len(_UpperCAmelCase						) + 1 + len(_UpperCAmelCase						))      ,)







							def 				__lowercase     (				self   :			Dict						):
									# 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(_UpperCAmelCase						) 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 				__lowercase     (				self   :			List[Any]						):
									super().test_tokenization_python_rust_equals()







							def 				__lowercase     (				self   :			str						):
									# CLIP always lower cases letters
									pass









'''simple docstring'''

def 	__lowerCamelCase	( )     -> Union[str, Any]:
		_a	: Optional[Any]								=				[]
		_a	: List[str]								=				1

		while len(lowerCAmelCase_    ) < 1E6:
				constant.append(str(lowerCAmelCase_    )    )
				i += 1

		_a	: Optional[Any]								=				''.join(lowerCAmelCase_    )

		return (
		    int(constant[0]    )
		    * int(constant[9]    )
		    * int(constant[99]    )
		    * int(constant[999]    )
		    * int(constant[9999]    )
		    * int(constant[99999]    )
		    * int(constant[999999]    )
		)


if __name__ == "__main__":
							print(solution())




