






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[Any]				=				logging.get_logger(__name__)

A_	:	str				=				{'vocab_file': 'vocab.txt'}

A_	:	Any				=				{
    '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_	:	List[str]				=				{
    'tau/splinter-base': 512,
    'tau/splinter-base-qass': 512,
    'tau/splinter-large': 512,
    'tau/splinter-large-qass': 512,
}

A_	:	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        _lowerCAmelCase( UpperCAmelCase_      ):





       """simple docstring"""







       a       :	Optional[int]								=VOCAB_FILES_NAMES
       a       :	Optional[Any]								=PRETRAINED_VOCAB_FILES_MAP
       a       :	Optional[int]								=PRETRAINED_INIT_CONFIGURATION
       a       :	List[Any]								=PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       a       :	List[str]								=SplinterTokenizer





       def __init__(      self						,    _lowerCamelCase=None						,    _lowerCamelCase=None						,    _lowerCamelCase=True						,    _lowerCamelCase="[UNK]"						,    _lowerCamelCase="[SEP]"						,    _lowerCamelCase="[PAD]"						,    _lowerCamelCase="[CLS]"						,    _lowerCamelCase="[MASK]"						,    _lowerCamelCase="[QUESTION]"						,    _lowerCamelCase=True						,    _lowerCamelCase=None						,    **_lowerCamelCase						,    ):
         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						,    )

         UpperCamelCase_:      Tuple					   =       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
         ):
           UpperCamelCase_:      str					   =       getattr(_lowerCamelCase						,    pre_tok_state.pop('type'							)							)
           UpperCamelCase_:      List[Any]					   =       do_lower_case
           UpperCamelCase_:      Optional[int]					   =       strip_accents
           UpperCamelCase_:      List[Any]					   =       pre_tok_class(**_lowerCamelCase							)

         UpperCamelCase_:      List[Any]					   =       do_lower_case





       @property
       def     _a					(      self							):
         return self.convert_tokens_to_ids(self.question_token							)





       def     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase = None							):
         if token_ids_a is None:
           return [self.cls_token_id] + token_ids_a + [self.sep_token_id]

         UpperCamelCase_:      List[str]					   =       [self.cls_token_id]
         UpperCamelCase_:      str					   =       [self.sep_token_id]
         UpperCamelCase_:      Any					   =       [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     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase = None							):
         UpperCamelCase_:      Dict					   =       [self.sep_token_id]
         UpperCamelCase_:      str					   =       [self.cls_token_id]
         UpperCamelCase_:      Optional[int]					   =       [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     _a					(      self						,    _lowerCamelCase						,    _lowerCamelCase = None							):
         UpperCamelCase_:      Any					   =       self._tokenizer.model.save(_lowerCamelCase						,    name=_lowerCamelCase							)
         return tuple(_lowerCamelCase							)







from math import factorial

def 						snake_case      (UpperCAmelCase__			,					UpperCAmelCase__						) ->       Dict:
  return factorial(UpperCAmelCase__						) / (factorial(UpperCAmelCase__						) * factorial(n - r						))

def 						snake_case      () ->       Optional[Any]:
  UpperCamelCase_:      int					   =       0

  for i in range(1			,					1_0_1						):
    for j in range(1			,					i + 1						):
      if combinations(UpperCAmelCase__			,					UpperCAmelCase__						) > 1E6:
        total += 1
  return total


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