






from math import factorial

A__			:    Optional[int]         =				{str(digit): factorial(digit) for digit in range(10)}






def 						a    (		lowerCamelCase_       ):






				'''simple docstring'''
				if not isinstance(__UpperCamelCase	,     __UpperCamelCase       ):
								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(__UpperCamelCase       )       )






def 						a    (		lowerCamelCase_ = 60	,     lowerCamelCase_ = 100_0000       ):






				'''simple docstring'''

				if not isinstance(__UpperCamelCase	,     __UpperCamelCase       ) or not isinstance(__UpperCamelCase	,     __UpperCamelCase       ):
								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
				lowercase__     				=    0
				# the cached sizes of the previous chains
				lowercase__     				=    {}

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

								# Stop computing the chain when you find a cached size, a repeating item or the
								# length is greater then the desired one.
								lowercase__     				=    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(__UpperCamelCase       )
												chain_set_length += 1
												lowercase__     				=    digit_factorial_sum(__UpperCamelCase       )

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

								lowercase__     				=    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()}")







class    _UpperCAmelCase      :

				"""simple docstring"""




				def __init__(  self		:					Optional[int],						lowerCamelCase		:					Union[str, Any]						):

								'''simple docstring'''
								# we need a list not a string, so do something to change the type
								lowercase__     				=    arr.split(''','''						)




				def        lowercase__     (  self		:					Optional[int]						):

								'''simple docstring'''
								lowercase__     				=    [int(self.array[0]						)] * len(self.array						)
								lowercase__     				=    [int(self.array[0]						)] * len(self.array						)
								for i in range(1,						len(self.array						)						):
												lowercase__     				=    max(
												    int(self.array[i]						) + sum_value[i - 1],						int(self.array[i]						)						)
												lowercase__     				=    max(sum_value[i],						rear[i - 1]						)
								return rear[len(self.array						) - 1]


if __name__ == "__main__":
							A__			:    Dict         =				input('please input some numbers:')
							A__			:    Union[str, Any]         =				SubArray(whole_array)
							A__			:    int         =				array.solve_sub_array()
							print(('the results is:', re))




