


'''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__		: Optional[int]												=  logging.get_logger(__name__)

A__		: Optional[Any]												=  {"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt""", """tokenizer_file""": """tokenizer.json"""}

A__		: Optional[int]												=  {
    """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__		: Any												=  {
    """openai/clip-vit-base-patch32""": 77,
}





class        UpperCAmelCase_  (_UpperCAmelCase  ):





    """simple docstring"""






    lowerCamelCase  : Union[str, Any]												=      VOCAB_FILES_NAMES
    lowerCamelCase  : Optional[int]												=      PRETRAINED_VOCAB_FILES_MAP
    lowerCamelCase  : str												=      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowerCamelCase  : Union[str, Any]												=      ['input_ids', 'attention_mask']
    lowerCamelCase  : Optional[Any]												=      CLIPTokenizer







    def __init__(							self      ,					SCREAMING_SNAKE_CASE_=None      ,					SCREAMING_SNAKE_CASE_=None      ,					SCREAMING_SNAKE_CASE_=None      ,					SCREAMING_SNAKE_CASE_="<|endoftext|>"      ,					SCREAMING_SNAKE_CASE_="<|startoftext|>"      ,					SCREAMING_SNAKE_CASE_="<|endoftext|>"      ,					SCREAMING_SNAKE_CASE_="<|endoftext|>"      ,					**SCREAMING_SNAKE_CASE_      ,					)    ->					Union[str, Any]:
         super().__init__(
             SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_      ,					tokenizer_file=SCREAMING_SNAKE_CASE_      ,					unk_token=SCREAMING_SNAKE_CASE_      ,					bos_token=SCREAMING_SNAKE_CASE_      ,					eos_token=SCREAMING_SNAKE_CASE_      ,					pad_token=SCREAMING_SNAKE_CASE_      ,					**SCREAMING_SNAKE_CASE_      ,					)

         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     )    ->					Optional[Any]:
         __lowerCamelCase       :     Union[str, Any]        =		self.backend_tokenizer.decode

         def new_decode_method(*SCREAMING_SNAKE_CASE_      ,					**SCREAMING_SNAKE_CASE_     ):
              __lowerCamelCase       :     int        =		orig_decode_method(*SCREAMING_SNAKE_CASE_      ,					**SCREAMING_SNAKE_CASE_     )
              __lowerCamelCase       :     List[str]        =		text.replace(self.backend_tokenizer.model.end_of_word_suffix      ,					' '     ).strip()
              return text

         __lowerCamelCase       :     Union[str, Any]        =		new_decode_method







    def 				lowercase_    (							self      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_ = None     )    ->					List[int]:
         __lowerCamelCase       :     Optional[int]        =		[self.bos_token_id]
         __lowerCamelCase       :     Tuple        =		[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      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_ = None     )    ->					List[int]:
         __lowerCamelCase       :     Dict        =		[self.bos_token_id]
         __lowerCamelCase       :     Optional[Any]        =		[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      ,					SCREAMING_SNAKE_CASE_      ,					SCREAMING_SNAKE_CASE_ = None     )    ->					Tuple[str]:
         __lowerCamelCase       :     int        =		self._tokenizer.model.save(SCREAMING_SNAKE_CASE_      ,					name=SCREAMING_SNAKE_CASE_     )
         return tuple(SCREAMING_SNAKE_CASE_     )










'''simple docstring'''



def       UpperCAmelCase__ (     UpperCAmelCase_   :    int = 4_00_00_00							)					->		int:
     __lowerCamelCase       :     int        =		1
     __lowerCamelCase       :     Union[str, Any]        =		2
     __lowerCamelCase       :     Optional[int]        =		0
     while j <= n:
          if j % 2 == 0:
               total += j
          __lowerCamelCase    ,	__lowerCamelCase       :     List[Any]        =		j, i + j

     return total


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






