


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

def     UpperCAmelCase_						(						_UpperCAmelCase       :Optional[int]							)  ->							List[Any]:
     '''simple docstring'''


     if not isinstance(lowercase_     ,	lowercase_							) or n < 1:
          return False

     # Initialization of sum and number of digits.
     A_					      =					0
     A_					      =					0
     A_					      =					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
     A_					      =					n
     while temp > 0:
          A_					      =					temp % 10
          total += rem**number_of_digits
          temp //= 10
     return n == total

def     UpperCAmelCase_						(						_UpperCAmelCase       :Tuple							)  ->							Any:
     '''simple docstring'''


     if not isinstance(lowercase_     ,	lowercase_							) or n < 1:
          return False

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

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

     return n == total

def     UpperCAmelCase_						(						_UpperCAmelCase       :Optional[int]							)  ->							Optional[Any]:
     '''simple docstring'''


     if not isinstance(lowercase_     ,	lowercase_							) or n < 1:
          return False
     A_					      =					len(str(lowercase_							)							)  # 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(lowercase_							) ** expo for i in str(lowercase_							)							)

def     UpperCAmelCase_						(						)  ->							Union[str, Any]:
     '''simple docstring'''


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


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()










from transformers import HfArgumentParser, PyTorchBenchmark, PyTorchBenchmarkArguments

def     UpperCAmelCase_						(						)  ->							Optional[int]:
     '''simple docstring'''


     A_					      =					HfArgumentParser(_UpperCAmelCase							)
     try:
          A_					      =					parser.parse_args_into_dataclasses()[0]
     except ValueError as e:
          A_					      =					'''Arg --no_{0} is no longer used, please use --no-{0} instead.'''
          A_					      =					''' '''.join(str(_UpperCAmelCase							).split(''' '''							)[:-1]							)
          A_					      =					''''''
          A_					      =					eval(str(_UpperCAmelCase							).split(''' '''							)[-1]							)
          A_					      =					[]
          for arg in depreciated_args:
               # arg[2:] removes '--'
               if arg[2:] in PyTorchBenchmarkArguments.deprecated_args:
                    # arg[5:] removes '--no_'
                    full_error_msg += arg_error_msg.format(arg[5:]							)
               else:
                    wrong_args.append(_UpperCAmelCase							)
          if len(_UpperCAmelCase							) > 0:
               A_					      =					full_error_msg + begin_error_msg + str(_UpperCAmelCase							)
          raise ValueError(_UpperCAmelCase							)

     A_					      =					PyTorchBenchmark(args=_UpperCAmelCase							)
     benchmark.run()


if __name__ == "__main__":
      main()



