





_SCREAMING_SNAKE_CASE   						=		(1, 1_53, 3_70, 3_71, 16_34, 24_67_80_51, 1_15_13_22_19_01_87_63_99_25_65_09_55_97_97_39_71_52_24_01)
_SCREAMING_SNAKE_CASE   						=		(-1_53, -1, 0, 1.2, 2_00, "A", [], {}, None)


def 				SCREAMING_SNAKE_CASE__    (     __a ):
	if not isinstance(__a ,			__a ) or n < 1:
		return False

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


def 				SCREAMING_SNAKE_CASE__    (     __a ):
	if not isinstance(__a ,			__a ) or n < 1:
		return False

	# Init a "histogram" of the digits
	snake_case_		:      Optional[int]           =						[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
	snake_case_		:      Dict           =						0
	snake_case_		:      Dict           =						0
	snake_case_		:      Tuple           =						n
	while temp > 0:
		snake_case_    ,snake_case_		:      List[Any]           =						divmod(__a ,			10 )
		digit_histogram[rem] += 1
		digit_total += 1

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

	return n == total


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


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


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						main()








"""simple docstring"""
import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging


_snake_case	:						int					=					logging.get_logger(__name__)

_snake_case	:						Optional[int]					=					{}






class    _UpperCAmelCase  (      lowercase_					):
					UpperCamelCase						=				'''fsmt_decoder'''


					def __init__(   self     :Optional[int]	,			__UpperCamelCase     :Tuple=0	,			__UpperCamelCase     :List[str]=0						):
												super().__init__()
												A						=    vocab_size
												A						=    bos_token_id







class    _UpperCAmelCase  (      lowercase_					):
					UpperCamelCase						=				'''fsmt'''
					UpperCamelCase						=				{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}


					def __init__(   self     :Dict	,			__UpperCamelCase     :List[str]=["en", "de"]	,			__UpperCamelCase     :List[str]=4_20_24	,			__UpperCamelCase     :Dict=4_20_24	,			__UpperCamelCase     :Tuple="relu"	,			__UpperCamelCase     :Optional[Any]=10_24	,			__UpperCamelCase     :Dict=2_00	,			__UpperCamelCase     :Optional[Any]=10_24	,			__UpperCamelCase     :Optional[Any]=40_96	,			__UpperCamelCase     :Union[str, Any]=12	,			__UpperCamelCase     :Dict=16	,			__UpperCamelCase     :Optional[Any]=0.0	,			__UpperCamelCase     :Dict=40_96	,			__UpperCamelCase     :Dict=12	,			__UpperCamelCase     :str=16	,			__UpperCamelCase     :Any=0.0	,			__UpperCamelCase     :str=0.0	,			__UpperCamelCase     :List[Any]=0.1	,			__UpperCamelCase     :List[Any]=0.0	,			__UpperCamelCase     :str=0.02	,			__UpperCamelCase     :List[str]=2	,			__UpperCamelCase     :Union[str, Any]=True	,			__UpperCamelCase     :Optional[Any]=True	,			__UpperCamelCase     :int=False	,			__UpperCamelCase     :List[str]=5	,			__UpperCamelCase     :Optional[int]=1.0	,			__UpperCamelCase     :List[str]=False	,			__UpperCamelCase     :Any=True	,			__UpperCamelCase     :List[str]=1	,			__UpperCamelCase     :int=0	,			__UpperCamelCase     :str=2	,			__UpperCamelCase     :Dict=2	,			**__UpperCamelCase     :Optional[int]	,			):
												A						=    langs
												A						=    src_vocab_size
												A						=    tgt_vocab_size
												A						=    d_model  # encoder_embed_dim and decoder_embed_dim

												A						=    encoder_ffn_dim
												A						=    A						=    encoder_layers
												A						=    encoder_attention_heads
												A						=    encoder_layerdrop
												A						=    decoder_layerdrop
												A						=    decoder_ffn_dim
												A						=    decoder_layers
												A						=    decoder_attention_heads
												A						=    max_position_embeddings
												A						=    init_std  # Normal(0, this parameter)
												A						=    activation_function

												A						=    DecoderConfig(vocab_size=__UpperCamelCase	,			bos_token_id=__UpperCamelCase						)
												if "decoder" in common_kwargs:
																			del common_kwargs["decoder"]

												A						=    scale_embedding  # scale factor will be sqrt(d_model) if True

												# 3 Types of Dropout
												A						=    attention_dropout
												A						=    activation_dropout
												A						=    dropout

												A						=    use_cache
												super().__init__(
												    pad_token_id=__UpperCamelCase	,			bos_token_id=__UpperCamelCase	,			eos_token_id=__UpperCamelCase	,			decoder_start_token_id=__UpperCamelCase	,			is_encoder_decoder=__UpperCamelCase	,			tie_word_embeddings=__UpperCamelCase	,			forced_eos_token_id=__UpperCamelCase	,			max_length=__UpperCamelCase	,			num_beams=__UpperCamelCase	,			length_penalty=__UpperCamelCase	,			early_stopping=__UpperCamelCase	,			**__UpperCamelCase	,			)


					def       lowerCamelCase			(   self     :List[str]						):
												A						=    copy.deepcopy(self.__dict__						)
												A						=    self.decoder.to_dict()
												A						=    self.__class__.model_type
												return output


