


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


def       a				(      __a       )  ->     datetime:



					'''simple docstring'''






					UpperCamelCase__       :int							 =			year % 19
					UpperCamelCase__       :Any							 =			year % 4
					UpperCamelCase__       :Dict							 =			year % 7
					UpperCamelCase__       :Tuple							 =			math.floor(year / 100       )
					UpperCamelCase__       :List[Any]							 =			math.floor((13 + 8 * leap_day_inhibits) / 25       )
					UpperCamelCase__       :Union[str, Any]							 =			leap_day_inhibits / 4
					UpperCamelCase__       :int							 =			(
					    15 - lunar_orbit_correction + leap_day_inhibits - leap_day_reinstall_number
					) % 30
					UpperCamelCase__       :List[Any]							 =			(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__       :Dict							 =			(
					    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(__a			, 4			, 19       )
					elif days_to_add == 28 and days_from_phm_to_sunday == 6:
										return datetime(__a			, 4			, 18       )
					else:
										return datetime(__a			, 3			, 22       ) + timedelta(
										    days=int(days_to_add + days_from_phm_to_sunday       )       )


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



'''simple docstring'''
from collections import Counter
from timeit import timeit


def       a				(      __a = ""			, )  ->     bool:



					'''simple docstring'''






					return sum(c % 2 for c in Counter(input_str.replace(''' '''			, ''''''       ).lower()       ).values()       ) < 2


def       a				(      __a = ""       )  ->     bool:



					'''simple docstring'''






					if len(__a       ) == 0:
										return True
					UpperCamelCase__       :List[Any]							 =			input_str.replace(''' '''			, ''''''       ).lower()
					# character_freq_dict: Stores the frequency of every character in the input string
					UpperCamelCase__       :dict[str, int]							 =			{}

					for character in lower_case_input_str:
										UpperCamelCase__       :Optional[int]							 =			character_freq_dict.get(__a			, 0       ) + 1
					UpperCamelCase__       :List[str]							 =			0

					for character_count in character_freq_dict.values():
										if character_count % 2:
															odd_char += 1
					if odd_char > 1:
										return False
					return True


def       a				(      __a = ""       )  ->     None:



					'''simple docstring'''






					print('''\nFor string = '''			, __a			, ''':'''       )
					print(
					    '''> can_string_be_rearranged_as_palindrome_counter()'''			, '''\tans ='''			, can_string_be_rearranged_as_palindrome_counter(__a       )			, '''\ttime ='''			, timeit(
					        '''z.can_string_be_rearranged_as_palindrome_counter(z.check_str)'''			, setup='''import __main__ as z'''			, )			, '''seconds'''			, )
					print(
					    '''> can_string_be_rearranged_as_palindrome()'''			, '''\tans ='''			, can_string_be_rearranged_as_palindrome(__a       )			, '''\ttime ='''			, timeit(
					        '''z.can_string_be_rearranged_as_palindrome(z.check_str)'''			, setup='''import __main__ as z'''			, )			, '''seconds'''			, )


if __name__ == "__main__":
		__snake_case											=					input(
		    '''Enter string to determine if it can be rearranged as a palindrome or not: '''
		).strip()
		benchmark(check_str)
		__snake_case											=					can_string_be_rearranged_as_palindrome_counter(check_str)
		print(F"""{check_str} can {'' if status else 'not '}be rearranged as a palindrome""")