




from math import factorial

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



def      __lowerCAmelCase			(					UpperCamelCase      )     ->	int:
		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      __lowerCAmelCase			(					UpperCamelCase = 60	,      UpperCamelCase = 1000000      )     ->	int:

		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
		lowerCAmelCase__				:  Any		       =     0
		# the cached sizes of the previous chains
		lowerCAmelCase__				:  str		       =     {}

		for start_chain_element in range(1	,      __UpperCamelCase      ):
				# The temporary set will contain the elements of the chain
				lowerCAmelCase__				:  List[Any]		       =     set()
				lowerCAmelCase__				:  Tuple		       =     0

				# Stop computing the chain when you find a cached size, a repeating item or the
				# length is greater then the desired one.
				lowerCAmelCase__				:  Any		       =     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
						lowerCAmelCase__				:  List[str]		       =     digit_factorial_sum(__UpperCamelCase      )

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

				lowerCAmelCase__				:  Optional[int]		       =     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()}""")







import math



def      __lowerCAmelCase			(					UpperCamelCase	,      UpperCamelCase      )     ->	float:
  if (
      not isinstance(UpperCamelCase	,      (int, float)      )
      or power_factor < -1
      or power_factor > 1
  ):
    raise ValueError('''power_factor must be a valid float value between -1 and 1.'''      )
  return apparent_power * power_factor



def      __lowerCAmelCase			(					UpperCamelCase	,      UpperCamelCase      )     ->	float:
  if (
      not isinstance(UpperCamelCase	,      (int, float)      )
      or power_factor < -1
      or power_factor > 1
  ):
    raise ValueError('''power_factor must be a valid float value between -1 and 1.'''      )
  return apparent_power * math.sqrt(1 - power_factor**2      )


if __name__ == "__main__":
     import doctest

     doctest.testmod()

