
'''simple docstring'''
import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_splinter import SplinterTokenizer


A__ :		Optional[int]					=logging.get_logger(__name__)

A__ :		List[str]					={'vocab_file': 'vocab.txt'}

A__ :		Optional[int]					={
    'vocab_file': {
        'tau/splinter-base': 'https://huggingface.co/tau/splinter-base/resolve/main/vocab.txt',
        'tau/splinter-base-qass': 'https://huggingface.co/tau/splinter-base-qass/resolve/main/vocab.txt',
        'tau/splinter-large': 'https://huggingface.co/tau/splinter-large/resolve/main/vocab.txt',
        'tau/splinter-large-qass': 'https://huggingface.co/tau/splinter-large-qass/resolve/main/vocab.txt',
    }
}

A__ :		str					={
    'tau/splinter-base': 512,
    'tau/splinter-base-qass': 512,
    'tau/splinter-large': 512,
    'tau/splinter-large-qass': 512,
}

A__ :		Union[str, Any]					={
    'tau/splinter-base': {'do_lower_case': False},
    'tau/splinter-base-qass': {'do_lower_case': False},
    'tau/splinter-large': {'do_lower_case': False},
    'tau/splinter-large-qass': {'do_lower_case': False},
}







class 			__A					(			lowerCamelCase_      ):
 lowerCamelCase												=VOCAB_FILES_NAMES
 lowerCamelCase												=PRETRAINED_VOCAB_FILES_MAP
 lowerCamelCase												=PRETRAINED_INIT_CONFIGURATION
 lowerCamelCase												=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 lowerCamelCase												=SplinterTokenizer
 def __init__( self      :     Tuple					, lowerCamelCase      :     Tuple=None					, lowerCamelCase      :     List[Any]=None					, lowerCamelCase      :     str=True					, lowerCamelCase      :     Dict="[UNK]"					, lowerCamelCase      :     Any="[SEP]"					, lowerCamelCase      :     Optional[int]="[PAD]"					, lowerCamelCase      :     int="[CLS]"					, lowerCamelCase      :     Any="[MASK]"					, lowerCamelCase      :     Union[str, Any]="[QUESTION]"					, lowerCamelCase      :     Union[str, Any]=True					, lowerCamelCase      :     Dict=None					, **lowerCamelCase      :     Union[str, Any]					, ):



   """simple docstring"""





   super().__init__(
       lowerCAmelCase_					, tokenizer_file=lowerCAmelCase_					, do_lower_case=lowerCAmelCase_					, unk_token=lowerCAmelCase_					, sep_token=lowerCAmelCase_					, pad_token=lowerCAmelCase_					, cls_token=lowerCAmelCase_					, mask_token=lowerCAmelCase_					, tokenize_chinese_chars=lowerCAmelCase_					, strip_accents=lowerCAmelCase_					, additional_special_tokens=(question_token,)					, **lowerCAmelCase_					, )

   __A		:  int       				=		json.loads(self.backend_tokenizer.normalizer.__getstate__()							)
   if (
       pre_tok_state.get("""lowercase"""					, lowerCAmelCase_							) != do_lower_case
       or pre_tok_state.get("""strip_accents"""					, lowerCAmelCase_							) != strip_accents
   ):
     __A		:  Tuple       				=		getattr(lowerCAmelCase_					, pre_tok_state.pop("""type"""							)							)
     __A		:  Any       				=		do_lower_case
     __A		:  List[str]       				=		strip_accents
     __A		:  Dict       				=		pre_tok_class(**lowerCAmelCase_							)

   __A		:  Union[str, Any]       				=		do_lower_case
 @property
 def 		lowercase_( self      :     str							):



   """simple docstring"""





   return self.convert_tokens_to_ids(self.question_token							)
 def 		lowercase_( self      :     str					, lowerCamelCase      :     Optional[int]					, lowerCamelCase      :     str = None							):



   """simple docstring"""





   if token_ids_a is None:
     return [self.cls_token_id] + token_ids_a + [self.sep_token_id]

   __A		:  Tuple       				=		[self.cls_token_id]
   __A		:  Tuple       				=		[self.sep_token_id]
   __A		:  Dict       				=		[self.question_token_id] + [self.convert_tokens_to_ids("""."""							)]
   if self.padding_side == "right":
     # Input is question-then-context
     return cls + token_ids_a + question_suffix + sep + token_ids_a + sep
   else:
     # Input is context-then-question
     return cls + token_ids_a + sep + token_ids_a + question_suffix + sep
 def 		lowercase_( self      :     List[str]					, lowerCamelCase      :     str					, lowerCamelCase      :     Optional[Any] = None							):



   """simple docstring"""





   __A		:  Optional[int]       				=		[self.sep_token_id]
   __A		:  Optional[int]       				=		[self.cls_token_id]
   __A		:  Tuple       				=		[self.question_token_id] + [self.convert_tokens_to_ids("""."""							)]
   if token_ids_a is None:
     return len(cls + token_ids_a + sep							) * [0]

   if self.padding_side == "right":
     # Input is question-then-context
     return len(cls + token_ids_a + question_suffix + sep							) * [0] + len(token_ids_a + sep							) * [1]
   else:
     # Input is context-then-question
     return len(cls + token_ids_a + sep							) * [0] + len(token_ids_a + question_suffix + sep							) * [1]






 def 		lowercase_( self      :     Union[str, Any]					, lowerCamelCase      :     int					, lowerCamelCase      :     str = None							):



   """simple docstring"""





   __A		:  int       				=		self._tokenizer.model.save(lowerCAmelCase_					, name=lowerCAmelCase_							)
   return tuple(lowerCAmelCase_							)




def 	__lowerCamelCase							(				)      ->       Dict:
	_lowercase   =1

	while True:
		if (
		    sorted(str(__a		)		)
		    == sorted(str(2 * i		)		)
		    == sorted(str(3 * i		)		)
		    == sorted(str(4 * i		)		)
		    == sorted(str(5 * i		)		)
		    == sorted(str(6 * i		)		)
		):
			return i

		i += 1


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




