




lowerCamelCase_  						=       (1, 153, 370, 371, 1634, 24678051, 115132219018763992565095597973971522401)
lowerCamelCase_  						=       (-153, -1, 0, 1.2, 200, "A", [], {}, None)



def      UpperCAmelCase_   (     __UpperCamelCase     ):
    if not isinstance(__UpperCamelCase,    __UpperCamelCase     ) or n < 1:
        return False

    # Initialization of sum and number of digits.
    SCREAMING_SNAKE_CASE__       =0
    SCREAMING_SNAKE_CASE__       =0
    SCREAMING_SNAKE_CASE__       =n
    # Calculation of digits of the number
    while temp > 0:
        number_of_digits += 1
        temp //= 10
    # Dividing number into separate digits and find Armstrong number
    SCREAMING_SNAKE_CASE__       =n
    while temp > 0:
        SCREAMING_SNAKE_CASE__       =temp % 10
        total += rem**number_of_digits
        temp //= 10
    return n == total



def      UpperCAmelCase_   (     __UpperCamelCase     ):
    if not isinstance(__UpperCamelCase,    __UpperCamelCase     ) or n < 1:
        return False

    # Init a "histogram" of the digits
    SCREAMING_SNAKE_CASE__       =[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
    SCREAMING_SNAKE_CASE__       =0
    SCREAMING_SNAKE_CASE__       =0
    SCREAMING_SNAKE_CASE__       =n
    while temp > 0:
        SCREAMING_SNAKE_CASE__      ,		SCREAMING_SNAKE_CASE__       =divmod(__UpperCamelCase,    10     )
        digit_histogram[rem] += 1
        digit_total += 1

    for cnt, i in zip(__UpperCamelCase,    range(len(__UpperCamelCase     )     )     ):
        total += cnt * i**digit_total

    return n == total



def      UpperCAmelCase_   (     __UpperCamelCase     ):
    if not isinstance(__UpperCamelCase,    __UpperCamelCase     ) or n < 1:
        return False
    SCREAMING_SNAKE_CASE__       =len(str(__UpperCamelCase     )     )  # the power that all digits will be raised to
    # check if sum of each digit multiplied expo times is equal to number
    return n == sum(int(__UpperCamelCase     ) ** expo for i in str(__UpperCamelCase     )     )



def      UpperCAmelCase_   (     ):
    SCREAMING_SNAKE_CASE__       =int(input("""Enter an integer to see if it is an Armstrong number: """     ).strip()     )
    print(f"""{num} is {"" if armstrong_number(__UpperCamelCase     ) else "not "}an Armstrong number."""     )
    print(f"""{num} is {"" if narcissistic_number(__UpperCamelCase     ) else "not "}an Armstrong number."""     )
    print(f"""{num} is {"" if pluperfect_number(__UpperCamelCase     ) else "not "}an Armstrong number."""     )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()












import os
from shutil import copyfile
from typing import Optional, Tuple

from ...file_utils import is_sentencepiece_available
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging


if is_sentencepiece_available():
    from .tokenization_deberta_va import DebertaVaTokenizer
else:
    lowerCamelCase_  						=       None

lowerCamelCase_  						=       logging.get_logger(__name__)

lowerCamelCase_  						=       {"vocab_file": "spm.model", "tokenizer_file": "tokenizer.json"}

lowerCamelCase_  						=       {
    "vocab_file": {
        "microsoft/deberta-v2-xlarge": "https://huggingface.co/microsoft/deberta-v2-xlarge/resolve/main/spm.model",
        "microsoft/deberta-v2-xxlarge": "https://huggingface.co/microsoft/deberta-v2-xxlarge/resolve/main/spm.model",
        "microsoft/deberta-v2-xlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-v2-xlarge-mnli/resolve/main/spm.model"
        ),
        "microsoft/deberta-v2-xxlarge-mnli": (
            "https://huggingface.co/microsoft/deberta-v2-xxlarge-mnli/resolve/main/spm.model"
        ),
    }
}

lowerCamelCase_  						=       {
    "microsoft/deberta-v2-xlarge": 512,
    "microsoft/deberta-v2-xxlarge": 512,
    "microsoft/deberta-v2-xlarge-mnli": 512,
    "microsoft/deberta-v2-xxlarge-mnli": 512,
}

lowerCamelCase_  						=       {
    "microsoft/deberta-v2-xlarge": {"do_lower_case": False},
    "microsoft/deberta-v2-xxlarge": {"do_lower_case": False},
    "microsoft/deberta-v2-xlarge-mnli": {"do_lower_case": False},
    "microsoft/deberta-v2-xxlarge-mnli": {"do_lower_case": False},
}
class 				__a (			__lowerCamelCase					):


     """simple docstring"""


     _A    :   str     =  VOCAB_FILES_NAMES
     _A    :   Union[str, Any]     =  PRETRAINED_VOCAB_FILES_MAP
     _A    :   Optional[int]     =  PRETRAINED_INIT_CONFIGURATION
     _A    :   Any     =  PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
     _A    :   Optional[int]     =  DebertaVaTokenizer




     def __init__(     self      :			List[Any]    ,_UpperCamelCase      :			Tuple=None    ,_UpperCamelCase      :			str=None    ,_UpperCamelCase      :			Any=False    ,_UpperCamelCase      :			List[Any]=False    ,_UpperCamelCase      :			Any="[CLS]"    ,_UpperCamelCase      :			Optional[int]="[SEP]"    ,_UpperCamelCase      :			int="[UNK]"    ,_UpperCamelCase      :			int="[SEP]"    ,_UpperCamelCase      :			Tuple="[PAD]"    ,_UpperCamelCase      :			Optional[Any]="[CLS]"    ,_UpperCamelCase      :			Optional[int]="[MASK]"    ,**_UpperCamelCase      :			int    ,)		->       None:


         '''simple docstring'''





         super().__init__(
             _UpperCamelCase    ,tokenizer_file=_UpperCamelCase    ,do_lower_case=_UpperCamelCase    ,bos_token=_UpperCamelCase    ,eos_token=_UpperCamelCase    ,unk_token=_UpperCamelCase    ,sep_token=_UpperCamelCase    ,pad_token=_UpperCamelCase    ,cls_token=_UpperCamelCase    ,mask_token=_UpperCamelCase    ,split_by_punct=_UpperCamelCase    ,**_UpperCamelCase    ,)

         SCREAMING_SNAKE_CASE__       =do_lower_case
         SCREAMING_SNAKE_CASE__       =split_by_punct
         SCREAMING_SNAKE_CASE__       =vocab_file
         SCREAMING_SNAKE_CASE__       =False if not self.vocab_file else True




     def   __A    (     self      :			Optional[Any]    ,_UpperCamelCase      :			int    ,_UpperCamelCase      :			str=None						)		->       Dict:


         '''simple docstring'''





         if token_ids_a is None:
             return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
         SCREAMING_SNAKE_CASE__       =[self.cls_token_id]
         SCREAMING_SNAKE_CASE__       =[self.sep_token_id]
         return cls + token_ids_a + sep + token_ids_a + sep




     def   __A    (     self      :			List[str]    ,_UpperCamelCase      :			Any    ,_UpperCamelCase      :			List[Any]=None    ,_UpperCamelCase      :			Union[str, Any]=False						)		->       str:


         '''simple docstring'''





         if already_has_special_tokens:
             return super().get_special_tokens_mask(
                 token_ids_a=_UpperCamelCase    ,token_ids_a=_UpperCamelCase    ,already_has_special_tokens=_UpperCamelCase						)

         if token_ids_a is not None:
             return [1] + ([0] * len(_UpperCamelCase						)) + [1] + ([0] * len(_UpperCamelCase						)) + [1]
         return [1] + ([0] * len(_UpperCamelCase						)) + [1]




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


         '''simple docstring'''





         SCREAMING_SNAKE_CASE__       =[self.sep_token_id]
         SCREAMING_SNAKE_CASE__       =[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   __A    (     self      :			int    ,_UpperCamelCase      :			str    ,_UpperCamelCase      :			Optional[str] = None						)		->       Tuple[str]:


         '''simple docstring'''





         if not self.can_save_slow_tokenizer:
             raise ValueError(
                 """Your fast tokenizer does not have the necessary information to save the vocabulary for a slow """
                 """tokenizer."""						)

         if not os.path.isdir(_UpperCamelCase						):
             logger.error(f"""Vocabulary path ({save_directory}) should be a directory"""						)
             return
         SCREAMING_SNAKE_CASE__       =os.path.join(
             _UpperCamelCase    ,(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""]						)

         if os.path.abspath(self.vocab_file						) != os.path.abspath(_UpperCamelCase						):
             copyfile(self.vocab_file    ,_UpperCamelCase						)

         return (out_vocab_file,)






