





import json
from typing import List, Optional, Tuple

from tokenizers import normalizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_convbert import ConvBertTokenizer


_a     :    str         =						logging.get_logger(__name__)

_a     :    int         =						{'vocab_file': 'vocab.txt'}

_a     :    int         =						{
    'vocab_file': {
        'YituTech/conv-bert-base': 'https://huggingface.co/YituTech/conv-bert-base/resolve/main/vocab.txt',
        'YituTech/conv-bert-medium-small': (
            'https://huggingface.co/YituTech/conv-bert-medium-small/resolve/main/vocab.txt'
        ),
        'YituTech/conv-bert-small': 'https://huggingface.co/YituTech/conv-bert-small/resolve/main/vocab.txt',
    }
}

_a     :    Dict         =						{
    'YituTech/conv-bert-base': 512,
    'YituTech/conv-bert-medium-small': 512,
    'YituTech/conv-bert-small': 512,
}


_a     :    Optional[int]         =						{
    'YituTech/conv-bert-base': {'do_lower_case': True},
    'YituTech/conv-bert-medium-small': {'do_lower_case': True},
    'YituTech/conv-bert-small': {'do_lower_case': True},
}
class   a_ (			lowercase_      ):
			A__      :			int       	=  VOCAB_FILES_NAMES
			A__      :			str       	=  PRETRAINED_VOCAB_FILES_MAP
			A__      :			Tuple       	=  PRETRAINED_INIT_CONFIGURATION
			A__      :			List[Any]       	=  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			A__      :			Optional[Any]       	=  ConvBertTokenizer

			def __init__(   self   :  Optional[int]     , UpperCAmelCase__   :  Dict=None     , UpperCAmelCase__   :  Dict=None     , UpperCAmelCase__   :  int=True     , UpperCAmelCase__   :  Dict="[UNK]"     , UpperCAmelCase__   :  Union[str, Any]="[SEP]"     , UpperCAmelCase__   :  List[Any]="[PAD]"     , UpperCAmelCase__   :  Tuple="[CLS]"     , UpperCAmelCase__   :  List[str]="[MASK]"     , UpperCAmelCase__   :  str=True     , UpperCAmelCase__   :  Dict=None     , **UpperCAmelCase__   :  List[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_     , **lowerCamelCase_     , )

							snake_case   :					Optional[int]    						=				json.loads(self.backend_tokenizer.normalizer.__getstate__()						)
							if (
							    normalizer_state.get('''lowercase'''     , lowerCamelCase_						) != do_lower_case
							    or normalizer_state.get('''strip_accents'''     , lowerCamelCase_						) != strip_accents
							    or normalizer_state.get('''handle_chinese_chars'''     , lowerCamelCase_						) != tokenize_chinese_chars
							):
											snake_case   :					List[Any]    						=				getattr(lowerCamelCase_     , normalizer_state.pop('''type'''						)						)
											snake_case   :					int    						=				do_lower_case
											snake_case   :					Optional[Any]    						=				strip_accents
											snake_case   :					int    						=				tokenize_chinese_chars
											snake_case   :					Any    						=				normalizer_class(**lowerCamelCase_						)

							snake_case   :					List[str]    						=				do_lower_case

			def      lowerCAmelCase(   self   :  int     , UpperCAmelCase__   :  Any     , UpperCAmelCase__   :  Optional[int]=None						):






							"""simple docstring"""
							snake_case   :					Dict    						=				[self.cls_token_id] + token_ids_a + [self.sep_token_id]

							if token_ids_a:
											output += token_ids_a + [self.sep_token_id]

							return output

			def      lowerCAmelCase(   self   :  str     , UpperCAmelCase__   :  List[int]     , UpperCAmelCase__   :  Optional[List[int]] = None						):






							"""simple docstring"""
							snake_case   :					Optional[Any]    						=				[self.sep_token_id]
							snake_case   :					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						) * [0] + len(token_ids_a + sep						) * [1]



			def      lowerCAmelCase(   self   :  List[Any]     , UpperCAmelCase__   :  str     , UpperCAmelCase__   :  Optional[str] = None						):






							"""simple docstring"""
							snake_case   :					List[Any]    						=				self._tokenizer.model.save(lowerCamelCase_     , name=lowerCamelCase_						)
							return tuple(lowerCamelCase_						)







'''simple docstring'''




from math import factorial



def 		__A		(  lowerCamelCase_			,			lowerCamelCase_	):


		"""simple docstring"""



		if n < k or k < 0:
				raise ValueError("""Please enter positive integers for n and k where n >= k"""	)
		return factorial(lowerCamelCase_	) // (factorial(lowerCamelCase_	) * factorial(n - k	))


if __name__ == "__main__":
							print(
							    """The number of five-card hands possible from a standard""",
							    f'''fifty-two card deck is: {combinations(52, 5)}\n''',
							)

							print(
							    """If a class of 40 students must be arranged into groups of""",
							    f'''4 for group projects, there are {combinations(40, 4)} ways''',
							    """to arrange them.\n""",
							)

							print(
							    """If 10 teams are competing in a Formula One race, there""",
							    f'''are {combinations(10, 3)} ways that first, second and''',
							    """third place can be awarded.""",
							)



