






'''simple docstring'''







from __future__ import annotations
def 						A__			(				__lowerCAmelCase		:			int = 4						):
						lowerCamelCase__         =  abs(__lowerCAmelCase						) or 4
						return [[1 + x + y * row_size for x in range(__lowerCAmelCase						)] for y in range(__lowerCAmelCase						)]
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						return reverse_row(transpose(__lowerCAmelCase						)						)
						# OR.. transpose(reverse_column(matrix))
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						return reverse_row(reverse_column(__lowerCAmelCase						)						)
						# OR.. reverse_column(reverse_row(matrix))
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						return reverse_column(transpose(__lowerCAmelCase						)						)
						# OR.. transpose(reverse_row(matrix))
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						lowerCamelCase__         =  [list(__lowerCAmelCase						) for x in zip(*__lowerCAmelCase						)]
						return matrix
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						lowerCamelCase__         =  matrix[::-1]
						return matrix
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						lowerCamelCase__         =  [x[::-1] for x in matrix]
						return matrix
def 						A__			(				__lowerCAmelCase		:			list[list[int]]						):
						for i in matrix:
												print(*__lowerCAmelCase						)


if __name__ == "__main__":
							UpperCamelCase    :      Any  			=		make_matrix()
							print('\norigin:\n')
							print_matrix(matrix)
							print('\nrotate 90 counterclockwise:\n')
							print_matrix(rotate_aa(matrix))

							UpperCamelCase    :      int  			=		make_matrix()
							print('\norigin:\n')
							print_matrix(matrix)
							print('\nrotate 180:\n')
							print_matrix(rotate_aaa(matrix))

							UpperCamelCase    :      Dict  			=		make_matrix()
							print('\norigin:\n')
							print_matrix(matrix)
							print('\nrotate 270 counterclockwise:\n')
							print_matrix(rotate_aaa(matrix))









'''simple docstring'''







from math import factorial

UpperCamelCase    :      dict[str, int]  			=		{str(digit): factorial(digit) for digit in range(10)}
def 						A__			(				__lowerCAmelCase		:			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 						A__			(				__lowerCAmelCase		:			int = 60   ,    __lowerCAmelCase		:			int = 100_0000						):

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

						for start_chain_element in range(1   ,    __lowerCAmelCase						):
												# 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(__lowerCAmelCase						)
																		chain_set_length += 1
																		lowerCamelCase__         =  digit_factorial_sum(__lowerCAmelCase						)

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

