




'''simple docstring'''






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






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      bool:
      if not isinstance(_UpperCAmelCase							,			_UpperCAmelCase		) or n < 1:
            return False

      # Initialization of sum and number of digits.
      snake_case__					:      List[str]  			=						0
      snake_case__					:      Tuple  			=						0
      snake_case__					:      Any  			=						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
      snake_case__					:      List[Any]  			=						n
      while temp > 0:
            snake_case__					:      Optional[int]  			=						temp % 10
            total += rem**number_of_digits
            temp //= 10
      return n == total






def 		UpperCamelCase__			(		__SCREAMING_SNAKE_CASE		)						->      bool:
      if not isinstance(_UpperCAmelCase							,			_UpperCAmelCase		) or n < 1:
            return False

      # Init a "histogram" of the digits
      snake_case__					:      Optional[Any]  			=						[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      snake_case__					:      str  			=						0
      snake_case__					:      Union[str, Any]  			=						0
      snake_case__					:      int  			=						n
      while temp > 0:
            snake_case__			,       snake_case__					:      Dict  			=						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__			(		__SCREAMING_SNAKE_CASE		)						->      bool:
      if not isinstance(_UpperCAmelCase							,			_UpperCAmelCase		) or n < 1:
            return False
      snake_case__					:      Optional[int]  			=						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__			(		)						->      Any:
      snake_case__					:      Tuple  			=						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()






'''simple docstring'''






from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_sentencepiece_available, is_torch_available


A_ 			=		{
    "configuration_ernie_m": ["ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP", "ErnieMConfig"],
}

try:
      if not is_sentencepiece_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A_ 			=		["ErnieMTokenizer"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      A_ 			=		[
          "ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST",
          "ErnieMForMultipleChoice",
          "ErnieMForQuestionAnswering",
          "ErnieMForSequenceClassification",
          "ErnieMForTokenClassification",
          "ErnieMModel",
          "ErnieMPreTrainedModel",
          "ErnieMForInformationExtraction",
      ]


if TYPE_CHECKING:
      from .configuration_ernie_m import ERNIE_M_PRETRAINED_CONFIG_ARCHIVE_MAP, ErnieMConfig

      try:
            if not is_sentencepiece_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_ernie_m import ErnieMTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_ernie_m import (
                ERNIE_M_PRETRAINED_MODEL_ARCHIVE_LIST,
                ErnieMForInformationExtraction,
                ErnieMForMultipleChoice,
                ErnieMForQuestionAnswering,
                ErnieMForSequenceClassification,
                ErnieMForTokenClassification,
                ErnieMModel,
                ErnieMPreTrainedModel,
            )


else:
      import sys

      A_ 			=		_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
