






"""simple docstring"""

def 		__lowerCamelCase	(  )						->    Tuple:

		"""simple docstring"""







		lowerCAmelCase_   :							Optional[Any]									=			[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

		lowerCAmelCase_   :							Tuple									=			6
		lowerCAmelCase_   :							List[str]									=			1
		lowerCAmelCase_   :							Union[str, Any]									=			1901

		lowerCAmelCase_   :							Union[str, Any]									=			0

		while year < 2001:
				day += 7

				if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
						if day > days_per_month[month - 1] and month != 2:
								month += 1
								lowerCAmelCase_   :							List[Any]									=			day - days_per_month[month - 2]
						elif day > 29 and month == 2:
								month += 1
								lowerCAmelCase_   :							Tuple									=			day - 29
				else:
						if day > days_per_month[month - 1]:
								month += 1
								lowerCAmelCase_   :							Any									=			day - days_per_month[month - 2]

				if month > 12:
						year += 1
						lowerCAmelCase_   :							List[str]									=			1

				if year < 2001 and day == 1:
						sundays += 1
		return sundays


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








"""simple docstring"""

from ..utils import DummyObject, requires_backends


class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Union[str, Any]            =							["""flax"""]





		def __init__(   self							:	Dict						,			*a_							:	Optional[Any]						,			**a_							:	List[str]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Optional[Any]						,			*a_							:	Union[str, Any]						,			**a_							:	Optional[Any]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	int						,			*a_							:	Union[str, Any]						,			**a_							:	Any	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				List[Any]            =							["""flax"""]





		def __init__(   self							:	Dict						,			*a_							:	Optional[Any]						,			**a_							:	Optional[Any]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	str						,			*a_							:	Union[str, Any]						,			**a_							:	List[Any]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[Any]						,			*a_							:	Optional[Any]						,			**a_							:	List[Any]	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Dict            =							["""flax"""]





		def __init__(   self							:	Any						,			*a_							:	Optional[int]						,			**a_							:	str	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Dict						,			*a_							:	Tuple						,			**a_							:	Dict	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Union[str, Any]						,			*a_							:	Any						,			**a_							:	Union[str, Any]	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Optional[Any]            =							["""flax"""]





		def __init__(   self							:	str						,			*a_							:	Optional[int]						,			**a_							:	Optional[Any]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Dict						,			*a_							:	Dict						,			**a_							:	str	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[Any]						,			*a_							:	Optional[int]						,			**a_							:	List[str]	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Optional[Any]            =							["""flax"""]





		def __init__(   self							:	Optional[Any]						,			*a_							:	Optional[Any]						,			**a_							:	Optional[Any]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	str						,			*a_							:	Optional[Any]						,			**a_							:	List[Any]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[str]						,			*a_							:	Union[str, Any]						,			**a_							:	List[Any]	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				List[Any]            =							["""flax"""]





		def __init__(   self							:	Union[str, Any]						,			*a_							:	Dict						,			**a_							:	Any	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Tuple						,			*a_							:	Optional[Any]						,			**a_							:	Tuple	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Optional[int]						,			*a_							:	List[Any]						,			**a_							:	Any	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				List[str]            =							["""flax"""]





		def __init__(   self							:	Union[str, Any]						,			*a_							:	str						,			**a_							:	Any	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Optional[Any]						,			*a_							:	Any						,			**a_							:	Tuple	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Optional[Any]						,			*a_							:	Optional[int]						,			**a_							:	str	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				int            =							["""flax"""]





		def __init__(   self							:	Dict						,			*a_							:	str						,			**a_							:	int	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	str						,			*a_							:	List[Any]						,			**a_							:	List[Any]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[Any]						,			*a_							:	List[Any]						,			**a_							:	List[Any]	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Tuple            =							["""flax"""]





		def __init__(   self							:	Any						,			*a_							:	Any						,			**a_							:	int	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Dict						,			*a_							:	Tuple						,			**a_							:	Optional[int]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[Any]						,			*a_							:	Dict						,			**a_							:	Dict	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Any            =							["""flax"""]





		def __init__(   self							:	Union[str, Any]						,			*a_							:	Any						,			**a_							:	List[Any]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Dict						,			*a_							:	List[Any]						,			**a_							:	Optional[int]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	int						,			*a_							:	List[Any]						,			**a_							:	Tuple	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Tuple            =							["""flax"""]





		def __init__(   self							:	Tuple						,			*a_							:	Optional[int]						,			**a_							:	Union[str, Any]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	int						,			*a_							:	List[str]						,			**a_							:	Optional[Any]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	Union[str, Any]						,			*a_							:	Any						,			**a_							:	Any	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				List[str]            =							["""flax"""]





		def __init__(   self							:	Optional[Any]						,			*a_							:	Optional[Any]						,			**a_							:	Dict	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[str]						,			*a_							:	int						,			**a_							:	List[str]	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[str]						,			*a_							:	int						,			**a_							:	str	):
				requires_backends(cls						,			["flax"]	)







class 		__lowerCamelCase				( metaclass=A__			):





		'''simple docstring'''






		a_	:				Any            =							["""flax"""]





		def __init__(   self							:	List[str]						,			*a_							:	Optional[Any]						,			**a_							:	List[Any]	):
				requires_backends(self						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	int						,			*a_							:	Optional[int]						,			**a_							:	Dict	):
				requires_backends(cls						,			["flax"]	)





		@classmethod
		def    lowerCamelCase       (   cls							:	List[str]						,			*a_							:	Union[str, Any]						,			**a_							:	Union[str, Any]	):
				requires_backends(cls						,			["flax"]	)
