



import math
from datetime import datetime, timedelta







def    _snake_case (       __snake_case    )     ->     datetime:






      '''simple docstring'''







      UpperCAmelCase_  :	Optional[int]				      =		year % 1_9
      UpperCAmelCase_  :	List[str]				      =		year % 4
      UpperCAmelCase_  :	str				      =		year % 7
      UpperCAmelCase_  :	Dict				      =		math.floor(year / 1_0_0    )
      UpperCAmelCase_  :	int				      =		math.floor((1_3 + 8 * leap_day_inhibits) / 2_5    )
      UpperCAmelCase_  :	Tuple				      =		leap_day_inhibits / 4
      UpperCAmelCase_  :	Union[str, Any]				      =		(
          1_5 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
      ) % 3_0
      UpperCAmelCase_  :	Union[str, Any]				      =		(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

      # PHM -> Paschal Full Moon
      UpperCAmelCase_  :	Union[str, Any]				      =		(
          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(__snake_case					,  4					,  1_9    )
      elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
            return datetime(__snake_case					,  4					,  1_8    )
      else:
            return datetime(__snake_case					,  3					,  2_2    ) + timedelta(
                days=int(days_to_add + days_from_phm_to_sunday    )    )


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






from __future__ import annotations

from collections import deque
from collections.abc import Iterator
from dataclasses import dataclass


@dataclass
class   snake_case_ :




       """simple docstring"""






       _lowerCamelCase			    =				42
       _lowerCamelCase			    =				42


class   snake_case_ :




       """simple docstring"""






       def __init__(     self     ,lowercase):

             """simple docstring"""





             UpperCAmelCase_  :	list[list[Edge]]				      =		[[] for _ in range(lowercase)]
             UpperCAmelCase_  :	str				      =		size



       def __getitem__(     self     ,lowercase):

             """simple docstring"""





             return iter(self._graph[vertex])



       @property
       def  A_   (     self):

             """simple docstring"""





             return self._size



       def  A_   (     self     ,lowercase     ,lowercase     ,lowercase):

             """simple docstring"""





             if weight not in (0, 1):
                   raise ValueError("Edge weight must be either 0 or 1.")

             if to_vertex < 0 or to_vertex >= self.size:
                   raise ValueError("Vertex indexes must be in [0; size).")

             self._graph[from_vertex].append(Edge(lowercase     ,lowercase))



       def  A_   (     self     ,lowercase     ,lowercase):

             """simple docstring"""





             UpperCAmelCase_  :	int				      =		deque([start_vertex])
             UpperCAmelCase_  :	list[int | None]				      =		[None] * self.size
             UpperCAmelCase_  :	Dict				      =		0

             while queue:
                   UpperCAmelCase_  :	List[Any]				      =		queue.popleft()
                   UpperCAmelCase_  :	Any				      =		distances[current_vertex]
                   if current_distance is None:
                         continue

                   for edge in self[current_vertex]:
                         UpperCAmelCase_  :	Tuple				      =		current_distance + edge.weight
                         UpperCAmelCase_  :	Optional[Any]				      =		distances[edge.destination_vertex]
                         if (
                             isinstance(lowercase     ,lowercase)
                             and new_distance >= dest_vertex_distance
                         ):
                               continue
                         UpperCAmelCase_  :	Tuple				      =		new_distance
                         if edge.weight == 0:
                               queue.appendleft(edge.destination_vertex)
                         else:
                               queue.append(edge.destination_vertex)

             if distances[finish_vertex] is None:
                   raise ValueError("No path from start_vertex to finish_vertex.")

             return distances[finish_vertex]


if __name__ == "__main__":
   import doctest

   doctest.testmod()
