

"""simple docstring"""


from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


__A		     =    logging.get_logger(__name__)

__A		     =    {"vocab_file": "vocab.json", "merges_file": "merges.txt", "tokenizer_file": "tokenizer.json"}

__A		     =    {
    "vocab_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json",
    },
    "merges_file": {
        "openai/clip-vit-base-patch32": "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt",
    },
    "tokenizer_file": {
        "openai/clip-vit-base-patch32": (
            "https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json"
        ),
    },
}

__A		     =    {
    "openai/clip-vit-base-patch32": 77,
}





class 					snake_case			(       __snake_case						):
				SCREAMING_SNAKE_CASE_     :   Dict        =						VOCAB_FILES_NAMES
				SCREAMING_SNAKE_CASE_     :   Optional[int]        =						PRETRAINED_VOCAB_FILES_MAP
				SCREAMING_SNAKE_CASE_     :   Tuple        =						PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
				SCREAMING_SNAKE_CASE_     :   Union[str, Any]        =						["""input_ids""", """attention_mask"""]
				SCREAMING_SNAKE_CASE_     :   str        =						CLIPTokenizer

				def __init__(			self							:       Tuple  ,						UpperCamelCase__							:       Optional[int]=None  ,						UpperCamelCase__							:       List[str]=None  ,						UpperCamelCase__							:       str=None  ,						UpperCamelCase__							:       Dict="<|endoftext|>"  ,						UpperCamelCase__							:       int="<|startoftext|>"  ,						UpperCamelCase__							:       Optional[int]="<|endoftext|>"  ,						UpperCamelCase__							:       Union[str, Any]="<|endoftext|>"  ,						**UpperCamelCase__							:       str  ,						)->     str:



						'''simple docstring'''


						super().__init__(
						    UpperCamelCase__  ,						UpperCamelCase__  ,						tokenizer_file=UpperCamelCase__  ,						unk_token=UpperCamelCase__  ,						bos_token=UpperCamelCase__  ,						eos_token=UpperCamelCase__  ,						pad_token=UpperCamelCase__  ,						**UpperCamelCase__  ,						)

						if not isinstance(self.backend_tokenizer.pre_tokenizer  ,						pre_tokenizers.Sequence):
								raise ValueError(
								    "The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been"
								    " heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using"
								    " to be compatible with this version.The easiest way to do so is"
								    " `CLIPTokenizerFast.from_pretrained(\"path_to_local_folder_or_hub_repo, from_slow=True)`. If you want"
								    " to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of"
								    " transformers.")

						self._wrap_decode_method_backend_tokenizer()

				def 							lowercase_  (			self							:       str)->     Optional[Any]:



						'''simple docstring'''


						__lowerCAmelCase: int					   =    self.backend_tokenizer.decode

						def new_decode_method(*UpperCamelCase__							:       Tuple  ,						**UpperCamelCase__							:       Optional[int]):
								__lowerCAmelCase: Optional[Any]					   =    orig_decode_method(*UpperCamelCase__  ,						**UpperCamelCase__)
								__lowerCAmelCase: Tuple					   =    text.replace(self.backend_tokenizer.model.end_of_word_suffix  ,						" ").strip()
								return text

						__lowerCAmelCase: List[Any]					   =    new_decode_method

				def 							lowercase_  (			self							:       Optional[Any]  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None)->     List[int]:



						'''simple docstring'''


						__lowerCAmelCase: Dict					   =    [self.bos_token_id]
						__lowerCAmelCase: str					   =    [self.eos_token_id]

						if token_ids_a is None:
								return bos_token + token_ids_a + eos_token
						return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token

				def 							lowercase_  (			self							:       Optional[int]  ,						UpperCamelCase__							:       List[int]  ,						UpperCamelCase__							:       Optional[List[int]] = None)->     List[int]:



						'''simple docstring'''


						__lowerCAmelCase: List[str]					   =    [self.bos_token_id]
						__lowerCAmelCase: Optional[int]					   =    [self.eos_token_id]

						if token_ids_a is None:
								return len(bos_token + token_ids_a + eos_token) * [0]
						return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token) * [0]




				def 							lowercase_  (			self							:       Union[str, Any]  ,						UpperCamelCase__							:       str  ,						UpperCamelCase__							:       Optional[str] = None)->     Tuple[str]:



						'''simple docstring'''


						__lowerCAmelCase: int					   =    self._tokenizer.model.save(UpperCamelCase__  ,						name=UpperCamelCase__)
						return tuple(UpperCamelCase__)





"""simple docstring"""


def 					a__					(					__SCREAMING_SNAKE_CASE = 1_0_0_0				)			->			int:
		__lowerCAmelCase: int					   =    0
		__lowerCAmelCase: Optional[int]					   =    0
		while 1:
				num += 3
				if num >= n:
						break
				total += num
				num += 2
				if num >= n:
						break
				total += num
				num += 1
				if num >= n:
						break
				total += num
				num += 3
				if num >= n:
						break
				total += num
				num += 1
				if num >= n:
						break
				total += num
				num += 2
				if num >= n:
						break
				total += num
				num += 3
				if num >= n:
						break
				total += num
		return total


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


