






'''simple docstring'''







import math





def  SCREAMING_SNAKE_CASE_       (UpperCamelCase      )      ->       list[int]:
							lowerCamelCase__					:	Tuple         =       []
							lowerCamelCase__					:	int         =       2
							lowerCamelCase__					:	str         =       int(math.sqrt(UpperCamelCase      )      )  # Size of every segment
							lowerCamelCase__					:	Optional[int]         =       [True] * (end + 1)
							lowerCamelCase__					:	List[str]         =       []

							while start <= end:
														if temp[start] is True:
																					in_prime.append(UpperCamelCase      )
																					for i in range(start * start				,			end + 1				,			UpperCamelCase      ):
																												lowerCamelCase__					:	Optional[int]         =       False
														start += 1
							prime += in_prime

							lowerCamelCase__					:	Optional[int]         =       end + 1
							lowerCamelCase__					:	Tuple         =       min(2 * end				,			UpperCamelCase      )

							while low <= n:
														lowerCamelCase__					:	Dict         =       [True] * (high - low + 1)
														for each in in_prime:
																					lowerCamelCase__					:	List[Any]         =       math.floor(low / each      ) * each
																					if t < low:
																												t += each

																					for j in range(UpperCamelCase				,			high + 1				,			UpperCamelCase      ):
																												lowerCamelCase__					:	Tuple         =       False

														for j in range(len(UpperCamelCase      )      ):
																					if temp[j] is True:
																												prime.append(j + low      )

														lowerCamelCase__					:	List[Any]         =       high + 1
														lowerCamelCase__					:	Any         =       min(high + end				,			UpperCamelCase      )

							return prime



print(sieve(10**6))







import math
from datetime import datetime, timedelta





def 		__A		(	__lowerCamelCase    )      ->       datetime:
	a										=							year % 19
	a										=							year % 4
	a										=							year % 7
	a										=							math.floor(year / 100    )
	a										=							math.floor((13 + 8 * leap_day_inhibits) / 25    )
	a										=							leap_day_inhibits / 4
	a										=							(
	    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 30
	a										=							(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

	# days to be added to March 21
	a										=							(19 * metonic_cycle + secular_moon_shift) % 30

	# PHM -> Paschal Full Moon
	a										=							(
	    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(__lowerCamelCase							,			4							,			19    )
	elif days_to_add == 28 and days_from_phm_to_sunday == 6:
		return datetime(__lowerCamelCase							,			4							,			18    )
	else:
		return datetime(__lowerCamelCase							,			3							,			22    ) + timedelta(
		    days=int(days_to_add + days_from_phm_to_sunday    )    )


if __name__ == "__main__":
		for year in (1_994, 2_000, 2_010, 2_021, 2_023):
				__UpperCamelCase					:       Tuple    					=      "will be" if year > datetime.now().year else "was"
				print(F'Easter in {year} {tense} {gauss_easter(year)}')

