




def 			__magic_name__				( A		:					Optional[Any]   ):






			'''simple docstring'''







			a    =			0
			a    =			len(A   )

			for i in range(n - 1   ):
						for j in range(i + 1,  A   ):
									if arr[i] > arr[j]:
												num_inversions += 1

			return num_inversions




def 			__magic_name__				( A		:					Any   ):






			'''simple docstring'''







			if len(A   ) <= 1:
						return arr, 0
			a    =			len(A   ) // 2
			a    =			arr[0:mid]
			a    =			arr[mid:]

			a    ,		a    =			count_inversions_recursive(A   )
			a    ,		a    =			count_inversions_recursive(A   )
			a    ,		a    =			_count_cross_inversions(A,  A   )

			a    =			inversion_p + inversions_q + cross_inversions
			return c, num_inversions




def 			__magic_name__				( A		:					Union[str, Any],  A		:					Any   ):






			'''simple docstring'''







			a    =			[]
			a    =			a    =			a    =			0
			while i < len(A   ) and j < len(A   ):
						if p[i] > q[j]:
									# if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
									# These are all inversions. The claim emerges from the
									# property that P is sorted.
									num_inversion += len(A   ) - i
									r.append(q[j]   )
									j += 1
						else:
									r.append(p[i]   )
									i += 1

			if i < len(A   ):
						r.extend(p[i:]   )
			else:
						r.extend(q[j:]   )

			return r, num_inversion




def 			__magic_name__				( ):






			'''simple docstring'''







			a    =			[10, 2, 1, 5, 5, 2, 11]

			# this arr has 8 inversions:
			# (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)

			a    =			count_inversions_bf(A   )
			a    ,		a    =			count_inversions_recursive(A   )

			assert num_inversions_bf == num_inversions_recursive == 8

			print("number of inversions = ",  A   )

			# testing an array with zero inversion (a sorted arr_1)

			arr_a.sort()
			a    =			count_inversions_bf(A   )
			a    ,		a    =			count_inversions_recursive(A   )

			assert num_inversions_bf == num_inversions_recursive == 0
			print("number of inversions = ",  A   )

			# an empty list should also have zero inversions
			a    =			[]
			a    =			count_inversions_bf(A   )
			a    ,		a    =			count_inversions_recursive(A   )

			assert num_inversions_bf == num_inversions_recursive == 0
			print("number of inversions = ",  A   )


if __name__ == "__main__":
		main()












import math
from datetime import datetime, timedelta





def 		__A		(	__lowerCamelCase    )      ->       datetime:
	a										=							year % 19
	a										=							year % 4
	a										=							year % 7
	a										=							math.floor(year / 100    )
	a										=							math.floor((13 + 8 * leap_day_inhibits) / 25    )
	a										=							leap_day_inhibits / 4
	a										=							(
	    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
	) % 30
	a										=							(4 + leap_day_inhibits - leap_day_reinstall_number) % 7

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

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


if __name__ == "__main__":
		for year in (1_994, 2_000, 2_010, 2_021, 2_023):
				__UpperCamelCase					:       Tuple    					=      "will be" if year > datetime.now().year else "was"
				print(F'Easter in {year} {tense} {gauss_easter(year)}')

