






from __future__ import annotations




class 							_lowerCAmelCase:





       """simple docstring"""







       def __init__(   self    ,     _lowerCamelCase				):
         UpperCamelCase_:   Union[str, Any]        =							order

         # a_{0} ... a_{k}
         UpperCamelCase_:   Tuple        =							[1.0] + [0.0] * order
         # b_{0} ... b_{k}
         UpperCamelCase_:   List[Any]        =							[1.0] + [0.0] * order

         # x[n-1] ... x[n-k]
         UpperCamelCase_:   Union[str, Any]        =							[0.0] * self.order
         # y[n-1] ... y[n-k]
         UpperCamelCase_:   int        =							[0.0] * self.order





       def      _a       (   self    ,     _lowerCamelCase    ,     _lowerCamelCase				):
         if len(_lowerCamelCase				) < self.order:
           UpperCamelCase_:   Any        =							[1.0, *a_coeffs]

         if len(_lowerCamelCase				) != self.order + 1:
           UpperCamelCase_:   Union[str, Any]        =							(
               f'''Expected a_coeffs to have {self.order + 1} elements '''
               f'''for {self.order}-order filter, got {len(_lowerCamelCase				)}'''
           )
           raise ValueError(_lowerCamelCase				)

         if len(_lowerCamelCase				) != self.order + 1:
           UpperCamelCase_:   int        =							(
               f'''Expected b_coeffs to have {self.order + 1} elements '''
               f'''for {self.order}-order filter, got {len(_lowerCamelCase				)}'''
           )
           raise ValueError(_lowerCamelCase				)

         UpperCamelCase_:   int        =							a_coeffs
         UpperCamelCase_:   Optional[Any]        =							b_coeffs





       def      _a       (   self    ,     _lowerCamelCase				):
         UpperCamelCase_:   List[str]        =							0.0

         # Start at index 1 and do index 0 at the end.
         for i in range(1    ,     self.order + 1				):
           result += (
               self.b_coeffs[i] * self.input_history[i - 1]
               - self.a_coeffs[i] * self.output_history[i - 1]
           )

         UpperCamelCase_:   Any        =							(result + self.b_coeffs[0] * sample) / self.a_coeffs[0]

         UpperCamelCase_:   Union[str, Any]        =							self.input_history[:-1]
         UpperCamelCase_:   int        =							self.output_history[:-1]

         UpperCamelCase_:   List[Any]        =							sample
         UpperCamelCase_:   List[str]        =							result

         return result



"""simple docstring"""



import math
from datetime import datetime, timedelta
def      UpperCAmelCase     (       _lowercase :   int	)						-> datetime:


	"""simple docstring"""




	lowerCAmelCase_      							=			year % 1_9
	lowerCAmelCase_      							=			year % 4
	lowerCAmelCase_      							=			year % 7
	lowerCAmelCase_      							=			math.floor(year / 1_0_0	)
	lowerCAmelCase_      							=			math.floor((1_3 + 8 * leap_day_inhibits) / 2_5	)
	lowerCAmelCase_      							=			leap_day_inhibits / 4
	lowerCAmelCase_      							=			(
	    1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 3_0
	lowerCAmelCase_      							=			(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

	# days to be added to March 21
	lowerCAmelCase_      							=			(1_9 * metonic_cycle + secular_moon_shift) % 3_0

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

	if days_to_add == 2_9 and days_from_phm_to_sunday == 6:
		return datetime(_lowercase			,   4			,   1_9	)
	elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
		return datetime(_lowercase			,   4			,   1_8	)
	else:
		return datetime(_lowercase			,   3			,   2_2	) + timedelta(
		    days=int(days_to_add + days_from_phm_to_sunday	)	)


if __name__ == "__main__":
		for year in (19_94, 20_00, 20_10, 20_21, 20_23):
				lowercase_							=							'will be' if year > datetime.now().year else 'was'
				print(f"""Easter in {year} {tense} {gauss_easter(year)}""")