



"""simple docstring"""
from __future__ import annotations

from collections.abc import Callable

A:     int										=	list[list[float | int]]

def    _snake_case		(		UpperCamelCase		:	Matrix    ,	UpperCamelCase		:	Matrix		):
 UpperCAmelCase			:      int			=			len(UpperCamelCase		)
 UpperCAmelCase			:      Matrix			=			[[0 for _ in range(size + 1		)] for _ in range(UpperCamelCase		)]
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int
 UpperCAmelCase			:      float

 for row in range(UpperCamelCase		):
  for col in range(UpperCamelCase		):
   UpperCAmelCase			:      int			=			matrix[row][col]

  UpperCAmelCase			:      Tuple			=			vector[row][0]

 UpperCAmelCase			:      str			=			0
 UpperCAmelCase			:      Dict			=			0
 while row < size and col < size:
  # pivoting
  UpperCAmelCase			:      Tuple			=			max((abs(augmented[rowa][col]		), rowa) for rowa in range(UpperCamelCase    ,	UpperCamelCase		)		)[
      1
  ]
  if augmented[pivot_row][col] == 0:
   col += 1
   continue
  else:
   UpperCAmelCase			,	UpperCAmelCase			:      Union[str, Any]			=			augmented[pivot_row], augmented[row]

  for rowa in range(row + 1    ,	UpperCamelCase		):
   UpperCAmelCase			:      str			=			augmented[rowa][col] / augmented[row][col]
   UpperCAmelCase			:      Optional[int]			=			0
   for cola in range(col + 1    ,	size + 1		):
    augmented[rowa][cola] -= augmented[row][cola] * ratio

  row += 1
  col += 1

 # back substitution
 for col in range(1    ,	UpperCamelCase		):
  for row in range(UpperCamelCase		):
   UpperCAmelCase			:      str			=			augmented[row][col] / augmented[col][col]
   for cola in range(UpperCamelCase    ,	size + 1		):
    augmented[row][cola] -= augmented[col][cola] * ratio

    # round to get rid of numbers like 2.000000000000004
 return [
     [round(augmented[row][size] / augmented[row][row]    ,	10		)] for row in range(UpperCamelCase		)
 ]

def    _snake_case		(		UpperCamelCase		:	list[int]		):
 UpperCAmelCase			:      int			=			len(UpperCamelCase		)
 UpperCAmelCase			:      Matrix			=			[[0 for _ in range(UpperCamelCase		)] for _ in range(UpperCamelCase		)]
 UpperCAmelCase			:      Matrix			=			[[0] for _ in range(UpperCamelCase		)]
 UpperCAmelCase			:      Matrix
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int
 UpperCAmelCase			:      int

 for x_val, y_val in enumerate(UpperCamelCase		):
  for col in range(UpperCamelCase		):
   UpperCAmelCase			:      Any			=			(x_val + 1) ** (size - col - 1)
  UpperCAmelCase			:      Tuple			=			y_val

 UpperCAmelCase			:      Dict			=			solve(UpperCamelCase    ,	UpperCamelCase		)

 def interpolated_func(UpperCamelCase		:	int		) -> int:
  return sum(
      round(coeffs[x_val][0]		) * (var ** (size - x_val - 1))
      for x_val in range(UpperCamelCase		)		)

 return interpolated_func

def    _snake_case		(		UpperCamelCase		:	int		):
 return (
     1
     - variable
     + variable**2
     - variable**3
     + variable**4
     - variable**5
     + variable**6
     - variable**7
     + variable**8
     - variable**9
     + variable**10
 )

def    _snake_case		(		UpperCamelCase		:	Callable[[int], int] = question_function    ,	UpperCamelCase		:	int = 10		):
 UpperCAmelCase			:      list[int]			=			[func(UpperCamelCase		) for x_val in range(1    ,	order + 1		)]

 UpperCAmelCase			:      list[Callable[[int], int]]			=			[
     interpolate(data_points[:max_coeff]		) for max_coeff in range(1    ,	order + 1		)
 ]

 UpperCAmelCase			:      int			=			0
 UpperCAmelCase			:      Callable[[int], int]
 UpperCAmelCase			:      int

 for poly in polynomials:
  UpperCAmelCase			:      Union[str, Any]			=			1
  while func(UpperCamelCase		) == poly(UpperCamelCase		):
   x_val += 1

  ret += poly(UpperCamelCase		)

 return ret


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





"""simple docstring"""
import math
from datetime import datetime, timedelta

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

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

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


if __name__ == "__main__":
      for year in (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
            A:     Any										=	"will be" if year > datetime.now().year else "was"
            print(f"""Easter in {year} {tense} {gauss_easter(year)}""")
