'''simple docstring'''




_lowercase		:				int	       =		[0, 2, 4, 6, 8]
_lowercase		:				str	       =		[1, 3, 5, 7, 9]




def 							lowerCamelCase			(   UpperCAmelCase__ :      int   ,   UpperCAmelCase__ :      int   ,   UpperCAmelCase__ :      list[int]   ,   UpperCAmelCase__ :      int				)    ->   int:
							if remaining_length == 0:
														if digits[0] == 0 or digits[-1] == 0:
																					return 0

														for i in range(length // 2 - 1   ,   -1   ,   -1				):
																					remainder += digits[i] + digits[length - i - 1]

																					if remainder % 2 == 0:
																												return 0

																					remainder //= 10

														return 1

							if remaining_length == 1:
														if remainder % 2 == 0:
																					return 0

														lowercase_      :    Optional[int]       		= 0
														for digit in range(10				):
																					lowercase_      :    Dict       		= digit
																					result += reversible_numbers(
																					    0   ,   (remainder + 2 * digit) // 10   ,   UpperCAmelCase__   ,   UpperCAmelCase__				)
														return result

							lowercase_      :    Tuple       		= 0
							for digita in range(10				):
														lowercase_      :    Any       		= digita

														if (remainder + digita) % 2 == 0:
																					lowercase_      :    Tuple       		= ODD_DIGITS
														else:
																					lowercase_      :    List[str]       		= EVEN_DIGITS

														for digita in other_parity_digits:
																					lowercase_      :    Optional[Any]       		= digita
																					result += reversible_numbers(
																					    remaining_length - 2   ,   (remainder + digita + digita) // 10   ,   UpperCAmelCase__   ,   UpperCAmelCase__   ,   )
							return result




def 							lowerCamelCase			(   UpperCAmelCase__ :      int = 9				)    ->   int:
							lowercase_      :    Tuple       		= 0
							for length in range(1   ,   max_power + 1				):
														result += reversible_numbers(UpperCAmelCase__   ,   0   ,   [0] * length   ,   UpperCAmelCase__				)
							return result


if __name__ == "__main__":
						print(f"""{solution() = }""")






'''simple docstring'''




import unittest

import numpy as np




def 							lowerCamelCase			(   UpperCAmelCase__ :      np.ndarray   ,   UpperCAmelCase__ :      np.ndarray   ,   UpperCAmelCase__ :      np.ndarray   ,   UpperCAmelCase__ :      np.ndarray | None = None   ,   )    ->   np.ndarray:
							lowercase_      :    List[Any]       		= np.shape(UpperCAmelCase__				)
							lowercase_      :    Dict       		= np.shape(UpperCAmelCase__				)
							lowercase_      :    int       		= np.shape(UpperCAmelCase__				)

							if shape_a[0] != shape_b[0]:
														lowercase_      :    Optional[int]       		= (
														    """Expected the same number of rows for A and B. """
														    F'''Instead found A of size {shape_a} and B of size {shape_b}'''
														)
														raise ValueError(UpperCAmelCase__				)

							if shape_b[1] != shape_c[1]:
														lowercase_      :    Optional[Any]       		= (
														    """Expected the same number of columns for B and C. """
														    F'''Instead found B of size {shape_b} and C of size {shape_c}'''
														)
														raise ValueError(UpperCAmelCase__				)

							lowercase_      :    Any       		= pseudo_inv
							if a_inv is None:
														try:
																					lowercase_      :    List[str]       		= np.linalg.inv(UpperCAmelCase__				)
														except np.linalg.LinAlgError:
																					raise ValueError(
																					    """Input matrix A is not invertible. Cannot compute Schur complement."""				)

							return mat_c - mat_b.T @ a_inv @ mat_b





class 					__magic_name__		(					unittest.TestCase):







			def 			SCREAMING_SNAKE_CASE_  (			self       :						Optional[int]					):
										lowercase_      :    Tuple       		= np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]					)
										lowercase_      :    int       		= np.array([[0, 3], [3, 0], [2, 3]]					)
										lowercase_      :    Dict       		= np.array([[2, 1], [6, 3]]					)

										lowercase_      :    Union[str, Any]       		= schur_complement(lowercase_       ,    lowercase_       ,    lowercase_					)

										lowercase_      :    List[Any]       		= np.block([[a, b], [b.T, c]]					)

										lowercase_      :    Optional[int]       		= np.linalg.det(lowercase_					)
										lowercase_      :    int       		= np.linalg.det(lowercase_					)
										lowercase_      :    int       		= np.linalg.det(lowercase_					)

										self.assertAlmostEqual(lowercase_       ,    det_a * det_s					)







			def 			SCREAMING_SNAKE_CASE_  (			self       :						str					):
										lowercase_      :    int       		= np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]					)
										lowercase_      :    Optional[Any]       		= np.array([[0, 3], [3, 0], [2, 3]]					)
										lowercase_      :    Union[str, Any]       		= np.array([[2, 1], [6, 3]]					)

										with self.assertRaises(lowercase_					):
																	schur_complement(lowercase_       ,    lowercase_       ,    lowercase_					)







			def 			SCREAMING_SNAKE_CASE_  (			self       :						Any					):
										lowercase_      :    List[Any]       		= np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]					)
										lowercase_      :    List[Any]       		= np.array([[0, 3], [3, 0], [2, 3]]					)
										lowercase_      :    str       		= np.array([[2, 1, 3], [6, 3, 5]]					)

										with self.assertRaises(lowercase_					):
																	schur_complement(lowercase_       ,    lowercase_       ,    lowercase_					)


if __name__ == "__main__":
						import doctest

						doctest.testmod()
						unittest.main()





