

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


def       __a       (   SCREAMING_SNAKE_CASE      )      ->     bool:






    '''simple docstring'''
    if not isinstance(SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE      ) or n < 1:
        return False

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


def       __a       (   SCREAMING_SNAKE_CASE      )      ->     bool:






    '''simple docstring'''
    if not isinstance(SCREAMING_SNAKE_CASE       ,   SCREAMING_SNAKE_CASE      ) or n < 1:
        return False

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

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

    return n == total


def       __a       (   SCREAMING_SNAKE_CASE      )      ->     bool:






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


def       __a       (   )      ->     Optional[Any]:






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


if __name__ == "__main__":
       import doctest

       doctest.testmod()
       main()








import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


A_		:			int										=   logging.get_logger(__name__)
class 					A_   (      _a						):


    '''simple docstring'''






    a__     							=       "speech-encoder-decoder"
    a__     							=       True


    def __init__(self     ,      **lowercase__  )     ->      Optional[int]:
        super().__init__(**lowercase__  )
        if "encoder" not in kwargs or "decoder" not in kwargs:
            raise ValueError(
                F'''A configuraton of type {self.model_type} cannot be instantiated because not both `encoder` and'''
                F''' `decoder` sub-configurations are passed, but only {kwargs}'''  )

        __UpperCAmelCase									=			kwargs.pop('''encoder'''  )
        __UpperCAmelCase									=			encoder_config.pop('''model_type'''  )
        __UpperCAmelCase									=			kwargs.pop('''decoder'''  )
        __UpperCAmelCase									=			decoder_config.pop('''model_type'''  )

        __UpperCAmelCase									=			AutoConfig.for_model(lowercase__     ,      **lowercase__  )
        __UpperCAmelCase									=			AutoConfig.for_model(lowercase__     ,      **lowercase__  )
        __UpperCAmelCase									=			True


    @classmethod
    def      lowerCAmelCase_						(cls     ,      lowercase__     ,      lowercase__     ,      **lowercase__  )     ->      PretrainedConfig:
        logger.info('''Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'''  )
        __UpperCAmelCase									=			True
        __UpperCAmelCase									=			True

        return cls(encoder=encoder_config.to_dict()     ,      decoder=decoder_config.to_dict()     ,      **lowercase__  )






    def      lowerCAmelCase_						(self  )     ->      Optional[Any]:
        __UpperCAmelCase									=			copy.deepcopy(self.__dict__  )
        __UpperCAmelCase									=			self.encoder.to_dict()
        __UpperCAmelCase									=			self.decoder.to_dict()
        __UpperCAmelCase									=			self.__class__.model_type
        return output




