






import math
from datetime import datetime, timedelta







def 			A__							(      _a  :					int	):





 '''simple docstring'''







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

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

 # PHM -> Paschal Full Moon
 snake_case__  :    Union[str, Any]							       =(
     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(_a		,  4		,  19	)
 elif days_to_add == 28 and days_from_phm_to_sunday == 6:
  return datetime(_a		,  4		,  18	)
 else:
  return datetime(_a		,  3		,  22	) + 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):
              __lowerCamelCase	:		Optional[int]										=   """will be""" if year > datetime.now().year else """was"""
              print(F"Easter in {year} {tense} {gauss_easter(year)}")













class  _lowercase   :
      def __init__(     self				,			a   ):
       snake_case__  :    Optional[int]							       =size
       snake_case__  :    List[Any]							       =[0] * size
       snake_case__  :    List[Any]							       =[0] * size
      @staticmethod
      def 						lowercase__					(     a   ):
       return index | (index + 1)
      @staticmethod
      def 						lowercase__					(     a   ):
       return (index & (index + 1)) - 1
      def 						lowercase__					(     self				,			a				,			a   ):
       snake_case__  :    Optional[Any]							       =value
       while index < self.size:
        snake_case__  :    str							       =self.get_prev(a   ) + 1
        if current_left_border == index:
         snake_case__  :    Dict							       =value
        else:
         snake_case__  :    str							       =max(a				,			a				,			a   )
        snake_case__  :    Dict							       =self.get_next(a   )



      def 						lowercase__					(     self				,			a				,			a   ):
       right -= 1  # Because of right is exclusive
       snake_case__  :    Union[str, Any]							       =0
       while left <= right:
        snake_case__  :    List[str]							       =self.get_prev(a   )
        if left <= current_left:
         snake_case__  :    Optional[Any]							       =max(a				,			self.tree[right]   )
         snake_case__  :    Optional[Any]							       =current_left
        else:
         snake_case__  :    Tuple							       =max(a				,			self.arr[right]   )
         right -= 1
       return result


if __name__ == "__main__":
       import doctest

       doctest.testmod()





