





import math
from datetime import datetime, timedelta





def 	lowerCAmelCase_					(			__a						)	->						datetime:







  """simple docstring"""





  lowerCamelCase__: List[str]         =year % 19
  lowerCamelCase__: int         =year % 4
  lowerCamelCase__: int         =year % 7
  lowerCamelCase__: Union[str, Any]         =math.floor(year / 100						)
  lowerCamelCase__: List[Any]         =math.floor((13 + 8 * leap_day_inhibits) / 25						)
  lowerCamelCase__: Optional[Any]         =leap_day_inhibits / 4
  lowerCamelCase__: int         =(
      15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
  ) % 30
  lowerCamelCase__: List[Any]         =(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

  # days to be added to March 21
  lowerCamelCase__: Optional[int]         =(19 * metonic_cycle + secular_moon_shift) % 30

  # PHM -> Paschal Full Moon
  lowerCamelCase__: Tuple         =(
      2 * julian_leap_year
      + 4 * non_leap_year
      + 6 * days_to_add
      + century_starting_point
  ) % 7

  if days_to_add == 29 and days_from_phm_to_sunday == 6:
    return datetime(__UpperCAmelCase      ,       4      ,       19						)
  elif days_to_add == 28 and days_from_phm_to_sunday == 6:
    return datetime(__UpperCAmelCase      ,       4      ,       18						)
  else:
    return datetime(__UpperCAmelCase      ,       3      ,       22						) + timedelta(
        days=int(days_to_add + days_from_phm_to_sunday						)						)


if __name__ == "__main__":
     for year in (1994, 2000, 2010, 2021, 2023):
          __A							   =							"will be" if year > datetime.now().year else "was"
          print(f'Easter in {year} {tense} {gauss_easter(year)}')






'''simple docstring'''

from __future__ import annotations







def a_     (    __UpperCAmelCase					)				->					list[int]:





			"""simple docstring"""







			snake_case:    Tuple      							=[True] * limit
			snake_case:    Optional[int]      							=False
			snake_case:    Union[str, Any]      							=False
			snake_case:    List[Any]      							=True

			for i in range(3				,							int(limit**0.5 + 1					)				,							2					):
						snake_case:    str      							=i * 2
						while index < limit:
									snake_case:    List[Any]      							=False
									snake_case:    List[str]      							=index + i

			snake_case:    Union[str, Any]      							=[2]

			for i in range(3				,							__UpperCAmelCase				,							2					):
						if is_prime[i]:
									primes.append(__UpperCAmelCase					)

			return primes







def a_     (    __UpperCAmelCase = 1_00_00_00					)				->					int:





			"""simple docstring"""







			snake_case:    str      							=prime_sieve(__UpperCAmelCase					)
			snake_case:    str      							=0
			snake_case:    str      							=0

			for i in range(len(__UpperCAmelCase					)					):
						for j in range(i + length				,							len(__UpperCAmelCase					)					):
									snake_case:    Tuple      							=sum(primes[i:j]					)
									if sol >= ceiling:
												break

									if sol in primes:
												snake_case:    List[str]      							=j - i
												snake_case:    Optional[int]      							=sol

			return largest


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




