






'''simple docstring'''

import math
from datetime import datetime, timedelta






def 	_UpperCAmelCase    (  a		:	int							)			->			datetime:





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

						# days to be added to March 21
						lowercase_      :   List[str]        =			(1_9 * metonic_cycle + secular_moon_shift) % 3_0

						# PHM -> Paschal Full Moon
						lowercase_      :   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 (1_9_9_4, 2_0_0_0, 2_0_1_0, 2_0_2_1, 2_0_2_3):
												A:      Optional[Any]  				=				"will be" if year > datetime.now().year else "was"
												print(f"""Easter in {year} {tense} {gauss_easter(year)}""")








'''simple docstring'''

def 	_UpperCAmelCase    (  a		:	list[list[float]]							)			->			list[list[float]]:





						"""simple docstring"""
						lowercase_      :   list[list[float]]        =			[]
						for data in source_data:
												for i, el in enumerate(a							):
																		if len(a							) < i + 1:
																								data_lists.append([]							)
																		data_lists[i].append(float(a							)							)
						return data_lists






def 	_UpperCAmelCase    (  a		:	list[list[float]]						,			a		:	list[int]							)			->			list[list[float]]:





						"""simple docstring"""
						lowercase_      :   list[list[float]]        =			[]
						for dlist, weight in zip(a						,			a							):
												lowercase_      :   Tuple        =			min(a							)
												lowercase_      :   Any        =			max(a							)

												lowercase_      :   list[float]        =			[]
												# for weight 0 score is 1 - actual score
												if weight == 0:
																		for item in dlist:
																								try:
																														score.append(1 - ((item - mind) / (maxd - mind))							)
																								except ZeroDivisionError:
																														score.append(1							)

												elif weight == 1:
																		for item in dlist:
																								try:
																														score.append((item - mind) / (maxd - mind)							)
																								except ZeroDivisionError:
																														score.append(0							)

        # weight not 0 or 1
												else:
																		lowercase_      :   str        =			f"Invalid weight of {weight:f} provided"
																		raise ValueError(a							)

												score_lists.append(a							)

						return score_lists






def 	_UpperCAmelCase    (  a		:	list[list[float]]							)			->			list[float]:





						"""simple docstring"""
						lowercase_      :   list[float]        =			[0 for i in range(len(score_lists[0]							)							)]

						for slist in score_lists:
												for j, ele in enumerate(a							):
																		lowercase_      :   List[Any]        =			final_scores[j] + ele

						return final_scores






def 	_UpperCAmelCase    (  a		:	list[list[float]]						,			a		:	list[int]							)			->			list[list[float]]:





						"""simple docstring"""
						lowercase_      :   int        =			get_data(a							)
						lowercase_      :   Optional[int]        =			calculate_each_score(a						,			a							)
						lowercase_      :   Dict        =			generate_final_scores(a							)

						# append scores to source data
						for i, ele in enumerate(a							):
												source_data[i].append(a							)

						return source_data
