




from collections import Counter
from timeit import timeit
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE = ""					,	):
			'''simple docstring'''
			return sum(c % 2 for c in Counter(input_str.replace(""" """					,	""""""   ).lower()   ).values()   ) < 2
def 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE = ""   ):
			'''simple docstring'''
			if len(SCREAMING_SNAKE_CASE   ) == 0:
						return True
			SCREAMING_SNAKE_CASE           =					input_str.replace(""" """					,	""""""   ).lower()
			# character_freq_dict: Stores the frequency of every character in the input string
			SCREAMING_SNAKE_CASE           =					{}

			for character in lower_case_input_str:
						SCREAMING_SNAKE_CASE           =					character_freq_dict.get(SCREAMING_SNAKE_CASE					,	0   ) + 1
			SCREAMING_SNAKE_CASE           =					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 					lowerCamelCase_    (    SCREAMING_SNAKE_CASE = ""   ):
			'''simple docstring'''
			print("""\nFor string = """					,	SCREAMING_SNAKE_CASE					,	""":"""   )
			print(
			    """> can_string_be_rearranged_as_palindrome_counter()"""					,	"""\tans ="""					,	can_string_be_rearranged_as_palindrome_counter(SCREAMING_SNAKE_CASE   )					,	"""\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(SCREAMING_SNAKE_CASE   )					,	"""\ttime ="""					,	timeit(
			        """z.can_string_be_rearranged_as_palindrome(z.check_str)"""					,	setup="""import __main__ as z"""					,	)					,	"""seconds"""					,	)


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












from __future__ import annotations




class 			UpperCAmelCase_      :




							'''simple docstring'''



							def __init__(					self       :	Optional[int]       ,     a       :	int = 0			)			->					str:
										SCREAMING_SNAKE_CASE           =					key





							def    _UpperCAmelCase     (					self       :	Tuple       ,     a       :	str       ,     a       :	int			)			->					list[str]:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key is an appropriate size
										key %= 255

										return [chr(ord(a			) ^ key			) for ch in content]





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	int			)			->					list[str]:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key is an appropriate size
										key %= 255

										return [chr(ord(a			) ^ key			) for ch in content]





							def    _UpperCAmelCase     (					self       :	Union[str, Any]       ,     a       :	str       ,     a       :	int = 0			)			->					str:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key can be any size
										while key > 255:
													key -= 255

										# This will be returned
										SCREAMING_SNAKE_CASE           =					""""""

										for ch in content:
													ans += chr(ord(a			) ^ key			)

										return ans





							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	int = 0			)			->					str:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										SCREAMING_SNAKE_CASE           =					key or self.__key or 1

										# make sure key can be any size
										while key > 255:
													key -= 255

										# This will be returned
										SCREAMING_SNAKE_CASE           =					""""""

										for ch in content:
													ans += chr(ord(a			) ^ key			)

										return ans





							def    _UpperCAmelCase     (					self       :	Optional[int]       ,     a       :	str       ,     a       :	int = 0			)			->					bool:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										try:
													with open(a			) as fin, open("""encrypt.out"""       ,     """w+"""			) as fout:
																# actual encrypt-process
																for line in fin:
																			fout.write(self.encrypt_string(a       ,     a			)			)

										except OSError:
													return False

										return True







							def    _UpperCAmelCase     (					self       :	Dict       ,     a       :	str       ,     a       :	int			)			->					bool:
										assert isinstance(a       ,     a			) and isinstance(a       ,     a			)

										try:
													with open(a			) as fin, open("""decrypt.out"""       ,     """w+"""			) as fout:
																# actual encrypt-process
																for line in fin:
																			fout.write(self.decrypt_string(a       ,     a			)			)

										except OSError:
													return False

										return True


# Tests
# crypt = XORCipher()
# key = 67

# # test encrypt
# print(crypt.encrypt("hallo welt",key))
# # test decrypt
# print(crypt.decrypt(crypt.encrypt("hallo welt",key), key))

# # test encrypt_string
# print(crypt.encrypt_string("hallo welt",key))

# # test decrypt_string
# print(crypt.decrypt_string(crypt.encrypt_string("hallo welt",key),key))

# if (crypt.encrypt_file("test.txt",key)):
#       print("encrypt successful")
# else:
#       print("encrypt unsuccessful")

# if (crypt.decrypt_file("encrypt.out",key)):
#       print("decrypt successful")
# else:
#       print("decrypt unsuccessful")






