





def 	lowerCAmelCase_					(			)	->						str:







  """simple docstring"""





  lowerCamelCase__: str         =[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

  lowerCamelCase__: List[str]         =6
  lowerCamelCase__: int         =1
  lowerCamelCase__: int         =1901

  lowerCamelCase__: List[str]         =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__: int         =day - days_per_month[month - 2]
      elif day > 29 and month == 2:
        month += 1
        lowerCamelCase__: Dict         =day - 29
    else:
      if day > days_per_month[month - 1]:
        month += 1
        lowerCamelCase__: Tuple         =day - days_per_month[month - 2]

    if month > 12:
      year += 1
      lowerCamelCase__: Union[str, Any]         =1

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


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









'''simple docstring'''

def 				snake_case       (  a_				:			str     , a_				:			Optional[int]						)							->					Any:





      """simple docstring"""

      UpperCamelCase_					: Tuple            =				(boundary[1] - boundary[0]) / steps
      UpperCamelCase_					: Dict            =				boundary[0]
      UpperCamelCase_					: Any            =				boundary[1]
      UpperCamelCase_					: Union[str, Any]            =				make_points(a_     , a_     , a_						)
      UpperCamelCase_					: Any            =				0.0
      y += (h / 2.0) * f(a_						)
      for i in x_i:
            # print(i)
            y += h * f(a_						)
      y += (h / 2.0) * f(a_						)
      return y



def 				snake_case       (  a_				:			Tuple     , a_				:			Any     , a_				:			Tuple						)							->					Tuple:





      """simple docstring"""

      UpperCamelCase_					: Optional[int]            =				a + h
      while x < (b - h):
            yield x
            UpperCamelCase_					: List[str]            =				x + h



def 				snake_case       (  a_				:			List[str]						)							->					Tuple:  # enter your function here





      """simple docstring"""

      UpperCamelCase_					: int            =				(x - 0) * (x - 0)
      return y



def 				snake_case       (  )							->					Dict:





      """simple docstring"""

      UpperCamelCase_					: Optional[Any]            =				0.0  # Lower bound of integration
      UpperCamelCase_					: Optional[int]            =				1.0  # Upper bound of integration
      UpperCamelCase_					: Optional[Any]            =				10.0  # define number of steps or resolution
      UpperCamelCase_					: Optional[Any]            =				[a, b]  # define boundary of integration
      UpperCamelCase_					: Any            =				method_a(a_     , a_						)
      print(f"y = {y}"						)


if __name__ == "__main__":
      main()






