


'''simple docstring'''






from math import factorial

__UpperCAmelCase					       =							{str(digit): factorial(digit) for digit in range(10)}


def       _snake_case     (  A )		->					int:
							if not isinstance(A				,					A ):
														raise TypeError('''Parameter number must be int''' )

							if number < 0:
														raise ValueError('''Parameter number must be greater than or equal to 0''' )

							# Converts number in string to iterate on its digits and adds its factorial.
							return sum(DIGIT_FACTORIAL[digit] for digit in str(A ) )


def       _snake_case     (  A = 60				,					A = 1000000 )		->					int:

							if not isinstance(A				,					A ) or not isinstance(A				,					A ):
														raise TypeError('''Parameters chain_length and number_limit must be int''' )

							if chain_length <= 0 or number_limit <= 0:
														raise ValueError(
														    '''Parameters chain_length and number_limit must be greater than 0''' )

							# the counter for the chains with the exact desired length
							lowerCAmelCase__      =			0
							# the cached sizes of the previous chains
							lowerCAmelCase__      =			{}

							for start_chain_element in range(1				,					A ):
														# The temporary set will contain the elements of the chain
														lowerCAmelCase__      =			set()
														lowerCAmelCase__      =			0

														# Stop computing the chain when you find a cached size, a repeating item or the
														# length is greater then the desired one.
														lowerCAmelCase__      =			start_chain_element
														while (
														    chain_element not in chain_sets_lengths
														    and chain_element not in chain_set
														    and chain_set_length <= chain_length
														):
																					chain_set.add(A )
																					chain_set_length += 1
																					lowerCAmelCase__      =			digit_factorial_sum(A )

														if chain_element in chain_sets_lengths:
																					chain_set_length += chain_sets_lengths[chain_element]

														lowerCAmelCase__      =			chain_set_length

														# If chain contains the exact amount of elements increase the counter
														if chain_set_length == chain_length:
																					chains_counter += 1

							return chains_counter


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		print(f"""{solution()}""")



'''simple docstring'''






def       _snake_case     (  A )		->					bool:
							if not isinstance(A				,					A ):
														raise ValueError('''Input series is not valid, valid series - [2, 4, 6]''' )
							if len(A ) == 0:
														raise ValueError('''Input list must be a non empty list''' )
							if len(A ) == 1:
														return True
							lowerCAmelCase__      =			series[1] - series[0]
							for index in range(len(A ) - 1 ):
														if series[index + 1] - series[index] != common_diff:
																					return False
							return True


def       _snake_case     (  A )		->					float:
							if not isinstance(A				,					A ):
														raise ValueError('''Input series is not valid, valid series - [2, 4, 6]''' )
							if len(A ) == 0:
														raise ValueError('''Input list must be a non empty list''' )
							lowerCAmelCase__      =			0
							for val in series:
														answer += val
							return answer / len(A )


if __name__ == "__main__":
		import doctest

		doctest.testmod()