




from math import factorial

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




def 						SCREAMING_SNAKE_CASE__ (   lowercase					)  ->       int:
			if not isinstance(_lowerCAmelCase						,_lowerCAmelCase					):
						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(_lowerCAmelCase					)					)




def 						SCREAMING_SNAKE_CASE__ (   lowercase = 60						,lowercase = 1000000					)  ->       int:

			if not isinstance(_lowerCAmelCase						,_lowerCAmelCase					) or not isinstance(_lowerCAmelCase						,_lowerCAmelCase					):
						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				:    str           =	0
			# the cached sizes of the previous chains
			snake_case				:    dict[int, int]           =	{}

			for start_chain_element in range(1						,_lowerCAmelCase					):
						# The temporary set will contain the elements of the chain
						snake_case				:    Tuple           =	set()
						snake_case				:    List[str]           =	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				:    Tuple           =	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(_lowerCAmelCase					)
									chain_set_length += 1
									snake_case				:    str           =	digit_factorial_sum(_lowerCAmelCase					)

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

						snake_case				:    List[str]           =	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()}""")











def 						SCREAMING_SNAKE_CASE__ (   lowercase						,lowercase					)  ->       int:
   return int((input_a, input_a).count(1					) != 0					)




def 						SCREAMING_SNAKE_CASE__ (   )  ->       None:
   assert or_gate(0						,0					) == 0
   assert or_gate(0						,1					) == 1
   assert or_gate(1						,0					) == 1
   assert or_gate(1						,1					) == 1


if __name__ == "__main__":
       print(or_gate(0, 1))
       print(or_gate(1, 0))
       print(or_gate(0, 0))
       print(or_gate(1, 1))





