


'''simple docstring'''







from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt






def 			lowercase				(_A					):







       """simple docstring"""







       _lowerCAmelCase    :							int   			=       int(number**0.5					)
       return number == sq * sq






def 			lowercase				(_A   ,						_A   ,						_A   ,						_A   ,						_A   ,						_A					):







       """simple docstring"""







       _lowerCAmelCase    :							int   			=       x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
       _lowerCAmelCase    :							int   			=       x_den * y_den * z_den
       _lowerCAmelCase    :							int   			=       gcd(_A   ,						_A					)
       top //= hcf
       bottom //= hcf
       return top, bottom






def 			lowercase				(_A = 3_5					):







       """simple docstring"""







       _lowerCAmelCase    :							set   			=       set()
       _lowerCAmelCase    :							int
       _lowerCAmelCase    :							Fraction   			=       Fraction(0					)
       _lowerCAmelCase    :							tuple[int, int]

       for x_num in range(1   ,						order + 1					):
              for x_den in range(x_num + 1   ,						order + 1					):
                     for y_num in range(1   ,						order + 1					):
                            for y_den in range(y_num + 1   ,						order + 1					):
                                   # n=1
                                   _lowerCAmelCase    :							List[str]   			=       x_num * y_den + x_den * y_num
                                   _lowerCAmelCase    :							List[Any]   			=       x_den * y_den
                                   _lowerCAmelCase    :							Any   			=       gcd(_A   ,						_A					)
                                   z_num //= hcf
                                   z_den //= hcf
                                   if 0 < z_num < z_den <= order:
                                          _lowerCAmelCase    :							List[str]   			=       add_three(
                                              _A   ,						_A   ,						_A   ,						_A   ,						_A   ,						_A					)
                                          unique_s.add(_A					)

                                   # n=2
                                   _lowerCAmelCase    :							str   			=       (
                                       x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
                                   )
                                   _lowerCAmelCase    :							List[str]   			=       x_den * x_den * y_den * y_den
                                   if is_sq(_A					) and is_sq(_A					):
                                          _lowerCAmelCase    :							Tuple   			=       int(sqrt(_A					)					)
                                          _lowerCAmelCase    :							List[Any]   			=       int(sqrt(_A					)					)
                                          _lowerCAmelCase    :							List[str]   			=       gcd(_A   ,						_A					)
                                          z_num //= hcf
                                          z_den //= hcf
                                          if 0 < z_num < z_den <= order:
                                                 _lowerCAmelCase    :							Optional[Any]   			=       add_three(
                                                     _A   ,						_A   ,						_A   ,						_A   ,						_A   ,						_A					)
                                                 unique_s.add(_A					)

                    # n=-1
                                   _lowerCAmelCase    :							Union[str, Any]   			=       x_num * y_num
                                   _lowerCAmelCase    :							List[Any]   			=       x_den * y_num + x_num * y_den
                                   _lowerCAmelCase    :							Optional[Any]   			=       gcd(_A   ,						_A					)
                                   z_num //= hcf
                                   z_den //= hcf
                                   if 0 < z_num < z_den <= order:
                                          _lowerCAmelCase    :							List[Any]   			=       add_three(
                                              _A   ,						_A   ,						_A   ,						_A   ,						_A   ,						_A					)
                                          unique_s.add(_A					)

                                   # n=2
                                   _lowerCAmelCase    :							Optional[int]   			=       x_num * x_num * y_num * y_num
                                   _lowerCAmelCase    :							List[str]   			=       (
                                       x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
                                   )
                                   if is_sq(_A					) and is_sq(_A					):
                                          _lowerCAmelCase    :							Optional[int]   			=       int(sqrt(_A					)					)
                                          _lowerCAmelCase    :							int   			=       int(sqrt(_A					)					)
                                          _lowerCAmelCase    :							int   			=       gcd(_A   ,						_A					)
                                          z_num //= hcf
                                          z_den //= hcf
                                          if 0 < z_num < z_den <= order:
                                                 _lowerCAmelCase    :							List[Any]   			=       add_three(
                                                     _A   ,						_A   ,						_A   ,						_A   ,						_A   ,						_A					)
                                                 unique_s.add(_A					)

       for num, den in unique_s:
              total += Fraction(_A   ,						_A					)

       return total.denominator + total.numerator


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





'''simple docstring'''







import math
from datetime import datetime, timedelta






def 			lowercase				(_A					):







       """simple docstring"""







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

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

       # PHM -> Paschal Full Moon
       _lowerCAmelCase    :							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(_A   ,						4   ,						1_9					)
       elif days_to_add == 2_8 and days_from_phm_to_sunday == 6:
              return datetime(_A   ,						4   ,						1_8					)
       else:
              return datetime(_A   ,						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):
              lowerCAmelCase    :     List[str]					=						"""will be""" if year > datetime.now().year else """was"""
              print(F'''Easter in {year} {tense} {gauss_easter(year)}''')

