


def        lowerCAmelCase_  (      ):
							__snake_case	:    Optional[int]											=     [3_1, 2_8, 3_1, 3_0, 3_1, 3_0, 3_1, 3_1, 3_0, 3_1, 3_0, 3_1]

							__snake_case	:    Any											=     6
							__snake_case	:    List[str]											=     1
							__snake_case	:    Tuple											=     1_9_0_1

							__snake_case	:    List[str]											=     0

							while year < 2_0_0_1:
														day += 7

														if (year % 4 == 0 and year % 1_0_0 != 0) or (year % 4_0_0 == 0):
																					if day > days_per_month[month - 1] and month != 2:
																												month += 1
																												__snake_case	:    Optional[int]											=     day - days_per_month[month - 2]
																					elif day > 2_9 and month == 2:
																												month += 1
																												__snake_case	:    Optional[Any]											=     day - 2_9
														else:
																					if day > days_per_month[month - 1]:
																												month += 1
																												__snake_case	:    Tuple											=     day - days_per_month[month - 2]

														if month > 1_2:
																					year += 1
																					__snake_case	:    Union[str, Any]											=     1

														if year < 2_0_0_1 and day == 1:
																					sundays += 1
							return sundays


if __name__ == "__main__":
			print(solution())





import unittest

import numpy as np







def        lowerCAmelCase_  (      __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase = None							,			):
							__snake_case	:    List[str]											=     np.shape(__lowerCamelCase			)
							__snake_case	:    Optional[Any]											=     np.shape(__lowerCamelCase			)
							__snake_case	:    List[str]											=     np.shape(__lowerCamelCase			)

							if shape_a[0] != shape_b[0]:
														__snake_case	:    Any											=     (
														    "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(__lowerCamelCase			)

							if shape_b[1] != shape_c[1]:
														__snake_case	:    int											=     (
														    "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(__lowerCamelCase			)

							__snake_case	:    str											=     pseudo_inv
							if a_inv is None:
														try:
																					__snake_case	:    Optional[Any]											=     np.linalg.inv(__lowerCamelCase			)
														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        a	(unittest.TestCase   ):




							"""simple docstring"""


							def 					__snake_case      (							self :						Tuple       )			->					None:
														__snake_case	:    str											=     np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]       )
														__snake_case	:    str											=     np.array([[0, 3], [3, 0], [2, 3]]       )
														__snake_case	:    Dict											=     np.array([[2, 1], [6, 3]]       )

														__snake_case	:    Dict											=     schur_complement(lowerCamelCase					,			lowerCamelCase					,			lowerCamelCase       )

														__snake_case	:    int											=     np.block([[a, b], [b.T, c]]       )

														__snake_case	:    Optional[int]											=     np.linalg.det(lowerCamelCase       )
														__snake_case	:    Any											=     np.linalg.det(lowerCamelCase       )
														__snake_case	:    Tuple											=     np.linalg.det(lowerCamelCase       )

														self.assertAlmostEqual(lowerCamelCase					,			det_a * det_s       )

							def 					__snake_case      (							self :						int       )			->					None:
														__snake_case	:    str											=     np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]       )
														__snake_case	:    Dict											=     np.array([[0, 3], [3, 0], [2, 3]]       )
														__snake_case	:    Tuple											=     np.array([[2, 1], [6, 3]]       )

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






							def 					__snake_case      (							self :						List[Any]       )			->					None:
														__snake_case	:    List[Any]											=     np.array([[1, 2, 1], [2, 1, 2], [3, 2, 4]]       )
														__snake_case	:    Tuple											=     np.array([[0, 3], [3, 0], [2, 3]]       )
														__snake_case	:    List[Any]											=     np.array([[2, 1, 3], [6, 3, 5]]       )

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


if __name__ == "__main__":
			import doctest

			doctest.testmod()
			unittest.main()

