






def _UpperCAmelCase   (	a						:	int  ,					a						:	Optional[Any] ):
							# "extended trapezoidal rule"
							# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
							snake_case__	  =       (boundary[1] - boundary[0]) / steps
							snake_case__	  =       boundary[0]
							snake_case__	  =       boundary[1]
							snake_case__	  =       make_points(a  ,					a  ,					a )
							snake_case__	  =       0.0
							y += (h / 2.0) * f(a )
							for i in x_i:
														# print(i)
														y += h * f(a )
							y += (h / 2.0) * f(a )
							return y

def _UpperCAmelCase   (	a						:	Dict  ,					a						:	Union[str, Any]  ,					a						:	Union[str, Any] ):
							snake_case__	  =       a + h
							while x < (b - h):
														yield x
														snake_case__	  =       x + h

def _UpperCAmelCase   (	a						:	Any ):  # enter your function here
							snake_case__	  =       (x - 0) * (x - 0)
							return y

def _UpperCAmelCase   (	):
							snake_case__	  =       0.0  # Lower bound of integration
							snake_case__	  =       1.0  # Upper bound of integration
							snake_case__	  =       10.0  # define number of steps or resolution
							snake_case__	  =       [a, b]  # define boundary of integration
							snake_case__	  =       method_a(a  ,					a )
							print(F'''y = {y}''' )


if __name__ == "__main__":
	main()








from math import factorial

a__       =     {str(digit): factorial(digit) for digit in range(1_0)}

def _UpperCAmelCase   (	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 _UpperCAmelCase   (	a						:	int = 60  ,					a						:	int = 100_0000 ):

							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
							snake_case__	  =       0
							# the cached sizes of the previous chains
							snake_case__	  =       {}

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

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

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

														snake_case__	  =       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()}''')
