



'''simple docstring'''




import copy
import re







class      _lowerCAmelCase							:
	__SCREAMING_SNAKE_CASE       :		Union[str, Any]		      = 'hp'
	__SCREAMING_SNAKE_CASE       :		Any		      = {}
	__SCREAMING_SNAKE_CASE       :		List[str]		      = None


	@classmethod
	def    _a     (cls	,				lowercase	,				lowercase							):
				A_     :						Optional[Any]     =					prefix
				A_     :						List[str]     =					defaults
				cls.build_naming_info()


	@staticmethod
	def    _a     (lowercase	,				lowercase							):
				if len(__lowercase							) == 0:
							return ""
				A_     :						List[str]     =					None
				if any(char.isdigit() for char in word							):
							raise Exception(F'Parameters should not contain numbers: \'{word}\' contains a number'							)
				if word in info["short_word"]:
							return info["short_word"][word]
				for prefix_len in range(1	,				len(__lowercase							) + 1							):
							A_     :						Optional[int]     =					word[:prefix_len]
							if prefix in info["reverse_short_word"]:
										continue
							else:
										A_     :						Any     =					prefix
										break

				if short_word is None:
							# Paranoid fallback
							def int_to_alphabetic(lowercase							):
										A_     :						List[Any]     =					""""""
										while integer != 0:
													A_     :						str     =					chr(ord("""A"""							) + integer % 10							) + s
													integer //= 10
										return s

							A_     :						List[Any]     =					0
							while True:
										A_     :						Optional[int]     =					word + """#""" + int_to_alphabetic(__lowercase							)
										if sword in info["reverse_short_word"]:
													continue
										else:
													A_     :						Union[str, Any]     =					sword
													break

				A_     :						Optional[int]     =					short_word
				A_     :						Union[str, Any]     =					word
				return short_word


	@staticmethod
	def    _a     (lowercase	,				lowercase							):
				A_     :						int     =					param_name.split("""_"""							)

				A_     :						Tuple     =					[TrialShortNamer.shortname_for_word(__lowercase	,				__lowercase							) for word in words]

				# We try to create a separatorless short name, but if there is a collision we have to fallback
				# to a separated short name
				A_     :						List[str]     =					["""""", """_"""]

				for separator in separators:
							A_     :						List[Any]     =					separator.join(__lowercase							)
							if shortname not in info["reverse_short_param"]:
										A_     :						Tuple     =					shortname
										A_     :						int     =					param_name
										return shortname

				return param_name


	@staticmethod
	def    _a     (lowercase	,				lowercase							):
				A_     :						List[str]     =					TrialShortNamer.shortname_for_key(__lowercase	,				__lowercase							)
				A_     :						List[str]     =					short_name
				A_     :						Optional[Any]     =					param_name


	@classmethod
	def    _a     (cls							):
				if cls.NAMING_INFO is not None:
							return

				A_     :						List[Any]     =					{
				    """short_word""": {},
				    """reverse_short_word""": {},
				    """short_param""": {},
				    """reverse_short_param""": {},
				}

				A_     :						Tuple     =					list(cls.DEFAULTS.keys()							)

				for k in field_keys:
							cls.add_new_param_name(__lowercase	,				__lowercase							)

				A_     :						Tuple     =					info


	@classmethod
	def    _a     (cls	,				lowercase							):
				cls.build_naming_info()
				assert cls.PREFIX is not None
				A_     :						List[str]     =					[copy.copy(cls.PREFIX							)]

				for k, v in params.items():
							if k not in cls.DEFAULTS:
										raise Exception(F'You should provide a default value for the param name {k} with value {v}'							)
							if v == cls.DEFAULTS[k]:
										# The default value is not added to the name
										continue

							A_     :						Optional[int]     =					cls.NAMING_INFO["""short_param"""][k]

							if isinstance(__lowercase	,				__lowercase							):
										A_     :						Dict     =					1 if v else 0

							A_     :						str     =					"""""" if isinstance(__lowercase	,				(int, float)							) else """-"""
							A_     :						Union[str, Any]     =					F'{key}{sep}{v}'
							name.append(__lowercase							)

				return "_".join(__lowercase							)


	@classmethod
	def    _a     (cls	,				lowercase							):
				A_     :						Any     =					repr[len(cls.PREFIX							) + 1 :]
				if repr == "":
							A_     :						int     =					[]
				else:
							A_     :						List[Any]     =					repr.split("""_"""							)

				A_     :						List[Any]     =					{}

				for value in values:
							if "-" in value:
										A_,   A_     :						List[Any]     =					value.split("""-"""							)
							else:
										A_     :						List[Any]     =					re.sub("""[0-9.]"""	,				""""""	,				__lowercase							)
										A_     :						Optional[Any]     =					float(re.sub("""[^0-9.]"""	,				""""""	,				__lowercase							)							)

							A_     :						List[Any]     =					cls.NAMING_INFO["""reverse_short_param"""][p_k]

							A_     :						Union[str, Any]     =					p_v

				for k in cls.DEFAULTS:
							if k not in parameters:
										A_     :						str     =					cls.DEFAULTS[k]

				return parameters




'''simple docstring'''




def      a      (			):
			'''simple docstring'''





			A_     :						Optional[int]     =					[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

			A_     :						Dict     =					6
			A_     :						List[Any]     =					1
			A_     :						Optional[Any]     =					19_01

			A_     :						Tuple     =					0

			while year < 20_01:
						day += 7

						if (year % 4 == 0 and year % 1_00 != 0) or (year % 4_00 == 0):
									if day > days_per_month[month - 1] and month != 2:
												month += 1
												A_     :						Optional[Any]     =					day - days_per_month[month - 2]
									elif day > 29 and month == 2:
												month += 1
												A_     :						str     =					day - 29
						else:
									if day > days_per_month[month - 1]:
												month += 1
												A_     :						List[str]     =					day - days_per_month[month - 2]

						if month > 12:
									year += 1
									A_     :						Tuple     =					1

						if year < 20_01 and day == 1:
									sundays += 1
			return sundays


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