






'''simple docstring'''



import json
from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers, processors

from ...tokenization_utils_base import AddedToken, BatchEncoding
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_bart import BartTokenizer


SCREAMING_SNAKE_CASE							=						logging.get_logger(__name__)


SCREAMING_SNAKE_CASE							=						{'vocab_file': 'vocab.json', 'merges_file': 'merges.txt', 'tokenizer_file': 'tokenizer.json'}

# See all BART models at https://huggingface.co/models?filter=bart
SCREAMING_SNAKE_CASE							=						{
    'vocab_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/vocab.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/vocab.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/vocab.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/vocab.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/vocab.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/vocab.json',
    },
    'merges_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/merges.txt',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/merges.txt',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/merges.txt',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/merges.txt',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/merges.txt',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/merges.txt',
    },
    'tokenizer_file': {
        'facebook/bart-base': 'https://huggingface.co/facebook/bart-base/resolve/main/tokenizer.json',
        'facebook/bart-large': 'https://huggingface.co/facebook/bart-large/resolve/main/tokenizer.json',
        'facebook/bart-large-mnli': 'https://huggingface.co/facebook/bart-large-mnli/resolve/main/tokenizer.json',
        'facebook/bart-large-cnn': 'https://huggingface.co/facebook/bart-large-cnn/resolve/main/tokenizer.json',
        'facebook/bart-large-xsum': 'https://huggingface.co/facebook/bart-large-xsum/resolve/main/tokenizer.json',
        'yjernite/bart_eli5': 'https://huggingface.co/yjernite/bart_eli5/resolve/main/tokenizer.json',
    },
}

SCREAMING_SNAKE_CASE							=						{
    'facebook/bart-base': 1_024,
    'facebook/bart-large': 1_024,
    'facebook/bart-large-mnli': 1_024,
    'facebook/bart-large-cnn': 1_024,
    'facebook/bart-large-xsum': 1_024,
    'yjernite/bart_eli5': 1_024,
}
class UpperCAmelCase_       (     __A					):




      """simple docstring"""




      UpperCamelCase_             =      VOCAB_FILES_NAMES
      UpperCamelCase_             =      PRETRAINED_VOCAB_FILES_MAP
      UpperCamelCase_             =      PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      UpperCamelCase_             =      ['''input_ids''', '''attention_mask''']
      UpperCamelCase_             =      BartTokenizer






      def __init__(			self      :		int  ,   UpperCAmelCase      :		Tuple=None  ,   UpperCAmelCase      :		int=None  ,   UpperCAmelCase      :		int=None  ,   UpperCAmelCase      :		str="replace"  ,   UpperCAmelCase      :		Any="<s>"  ,   UpperCAmelCase      :		Any="</s>"  ,   UpperCAmelCase      :		int="</s>"  ,   UpperCAmelCase      :		List[Any]="<s>"  ,   UpperCAmelCase      :		Optional[int]="<unk>"  ,   UpperCAmelCase      :		Optional[int]="<pad>"  ,   UpperCAmelCase      :		Tuple="<mask>"  ,   UpperCAmelCase      :		Any=False  ,   UpperCAmelCase      :		Union[str, Any]=True  ,   **UpperCAmelCase      :		Optional[Any]  ,   )	->	Tuple:


       '''simple docstring'''

       super().__init__(
           UpperCAmelCase  ,   UpperCAmelCase  ,   tokenizer_file=UpperCAmelCase  ,   errors=UpperCAmelCase  ,   bos_token=UpperCAmelCase  ,   eos_token=UpperCAmelCase  ,   sep_token=UpperCAmelCase  ,   cls_token=UpperCAmelCase  ,   unk_token=UpperCAmelCase  ,   pad_token=UpperCAmelCase  ,   mask_token=UpperCAmelCase  ,   add_prefix_space=UpperCAmelCase  ,   trim_offsets=UpperCAmelCase  ,   **UpperCAmelCase  ,   )

       lowercase       : Any						=json.loads(self.backend_tokenizer.pre_tokenizer.__getstate__()		)
       if pre_tok_state.get('''add_prefix_space'''  ,   UpperCAmelCase		) != add_prefix_space:
        lowercase       : int						=getattr(UpperCAmelCase  ,   pre_tok_state.pop('''type'''		)		)
        lowercase       : List[Any]						=add_prefix_space
        lowercase       : List[str]						=pre_tok_class(**UpperCAmelCase		)

       lowercase       : Optional[Any]						=add_prefix_space

       # the pre_tokenizer is already updated in the GPT2TokenizerFast `__init__`
       lowercase       : Dict						='''post_processor'''
       lowercase       : Optional[Any]						=getattr(self.backend_tokenizer  ,   UpperCAmelCase  ,   UpperCAmelCase		)
       if tokenizer_component_instance:
        lowercase       : str						=json.loads(tokenizer_component_instance.__getstate__()		)

        # The lists 'sep' and 'cls' must be cased in tuples for the object `post_processor_class`
        if "sep" in state:
         lowercase       : Optional[int]						=tuple(state['''sep''']		)
        if "cls" in state:
         lowercase       : int						=tuple(state['''cls''']		)

        lowercase       : Any						=False

        if state.get('''add_prefix_space'''  ,   UpperCAmelCase		) != add_prefix_space:
         lowercase       : Union[str, Any]						=add_prefix_space
         lowercase       : str						=True

        if state.get('''trim_offsets'''  ,   UpperCAmelCase		) != trim_offsets:
         lowercase       : List[Any]						=trim_offsets
         lowercase       : Tuple						=True

        if changes_to_apply:
         lowercase       : List[str]						=getattr(UpperCAmelCase  ,   state.pop('''type'''		)		)
         lowercase       : str						=component_class(**UpperCAmelCase		)
         setattr(self.backend_tokenizer  ,   UpperCAmelCase  ,   UpperCAmelCase		)






      @property
      def 					A__   (			self      :		int		)	->	str:


       '''simple docstring'''

       if self._mask_token is None:
        if self.verbose:
         logger.error('''Using mask_token, but it is not set yet.'''		)
        return None
       return str(self._mask_token		)






      @mask_token.setter
      def 					A__   (			self      :		Optional[Any]  ,   UpperCAmelCase      :		str		)	->	Optional[Any]:


       '''simple docstring'''

       lowercase       : str						=AddedToken(UpperCAmelCase  ,   lstrip=UpperCAmelCase  ,   rstrip=UpperCAmelCase		) if isinstance(UpperCAmelCase  ,   UpperCAmelCase		) else value
       lowercase       : str						=value






      def 					A__   (			self      :		int  ,   *UpperCAmelCase      :		Dict  ,   **UpperCAmelCase      :		Dict		)	->	BatchEncoding:


       '''simple docstring'''

       lowercase       : Optional[Any]						=kwargs.get('''is_split_into_words'''  ,   UpperCAmelCase		)

       if is_split_into_words and not self.add_prefix_space:
        raise ValueError(
            f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
            '''to use it with pretokenized inputs.'''		)

       return super()._batch_encode_plus(*UpperCAmelCase  ,   **UpperCAmelCase		)






      def 					A__   (			self      :		Optional[int]  ,   *UpperCAmelCase      :		Optional[int]  ,   **UpperCAmelCase      :		Optional[int]		)	->	BatchEncoding:


       '''simple docstring'''

       lowercase       : str						=kwargs.get('''is_split_into_words'''  ,   UpperCAmelCase		)

       if is_split_into_words and not self.add_prefix_space:
        raise ValueError(
            f'You need to instantiate {self.__class__.__name__} with add_prefix_space=True '
            '''to use it with pretokenized inputs.'''		)

       return super()._encode_plus(*UpperCAmelCase  ,   **UpperCAmelCase		)






      def 					A__   (			self      :		str  ,   UpperCAmelCase      :		str  ,   UpperCAmelCase      :		Optional[str] = None		)	->	Tuple[str]:


       '''simple docstring'''

       lowercase       : Optional[Any]						=self._tokenizer.model.save(UpperCAmelCase  ,   name=UpperCAmelCase		)
       return tuple(UpperCAmelCase		)






      def 					A__   (			self      :		int  ,   UpperCAmelCase      :		str  ,   UpperCAmelCase      :		List[Any]=None		)	->	Union[str, Any]:


       '''simple docstring'''

       lowercase       : Optional[Any]						=[self.bos_token_id] + token_ids_a + [self.eos_token_id]
       if token_ids_a is None:
        return output

       return output + [self.eos_token_id] + token_ids_a + [self.eos_token_id]






      def 					A__   (			self      :		Union[str, Any]  ,   UpperCAmelCase      :		List[int]  ,   UpperCAmelCase      :		Optional[List[int]] = None		)	->	List[int]:


       '''simple docstring'''

       lowercase       : Union[str, Any]						=[self.sep_token_id]
       lowercase       : str						=[self.cls_token_id]

       if token_ids_a is None:
        return len(cls + token_ids_a + sep		) * [0]
       return len(cls + token_ids_a + sep + sep + token_ids_a + sep		) * [0]




"""simple docstring"""




from itertools import permutations







def 				_UpperCAmelCase		(							lowerCamelCase__  ):





		"""simple docstring"""




		if num[3] % 2 != 0:
				return False

		if (num[2] + num[3] + num[4]) % 3 != 0:
				return False

		if num[5] % 5 != 0:
				return False

		lowerCAmelCase__   = [7, 11, 13, 17]
		for i, test in enumerate(lowerCamelCase__  ):
				if (num[i + 4] * 100 + num[i + 5] * 10 + num[i + 6]) % test != 0:
						return False
		return True







def 				_UpperCAmelCase		(							lowerCamelCase__ = 10  ):





		"""simple docstring"""




		return sum(
		    int("""""".join(map(lowerCamelCase__      ,	lowerCamelCase__  )  )  )
		    for num in permutations(range(lowerCamelCase__  )  )
		    if is_substring_divisible(lowerCamelCase__  )  )


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




