




'''simple docstring'''







from collections import Counter
from timeit import timeit



def        lowerCamelCase__				(      __lowercase = ""     ,   ):
     return sum(c % 2 for c in Counter(input_str.replace(""" """     ,   """"""				).lower()				).values()				) < 2



def        lowerCamelCase__				(      __lowercase = ""				):
     if len(__lowercase				) == 0:
          return True
     snake_case			:      Optional[int]        =			input_str.replace(""" """     ,   """"""				).lower()
     # character_freq_dict: Stores the frequency of every character in the input string
     snake_case			:      dict[str, int]        =			{}

     for character in lower_case_input_str:
          snake_case			:      Dict        =			character_freq_dict.get(__lowercase     ,   0				) + 1
     snake_case			:      Union[str, Any]        =			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__				(      __lowercase = ""				):
     print("""\nFor string = """     ,   __lowercase     ,   """:"""				)
     print(
         """> can_string_be_rearranged_as_palindrome_counter()"""     ,   """\tans ="""     ,   can_string_be_rearranged_as_palindrome_counter(__lowercase				)     ,   """\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(__lowercase				)     ,   """\ttime ="""     ,   timeit(
             """z.can_string_be_rearranged_as_palindrome(z.check_str)"""     ,   setup="""import __main__ as z"""     ,   )     ,   """seconds"""     ,   )


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









'''simple docstring'''







from __future__ import annotations







class 					_a :





     '''simple docstring'''



     def __init__(				self							,__a = 0							)      ->				str:
          snake_case			:      List[Any]        =			key







     def 			snake_case_      (				self							,__a							,__a							)      ->				list[str]:
          assert isinstance(__a							,__a							) and isinstance(__a							,__a							)

          snake_case			:      Tuple        =			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 			snake_case_      (				self							,__a							,__a							)      ->				list[str]:
          assert isinstance(__a							,__a							) and isinstance(__a							,__a							)

          snake_case			:      List[Any]        =			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 			snake_case_      (				self							,__a							,__a = 0							)      ->				str:
          assert isinstance(__a							,__a							) and isinstance(__a							,__a							)

          snake_case			:      List[Any]        =			key or self.__key or 1

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

          # This will be returned
          snake_case			:      List[str]        =			""""""

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

          return ans







     def 			snake_case_      (				self							,__a							,__a = 0							)      ->				str:
          assert isinstance(__a							,__a							) and isinstance(__a							,__a							)

          snake_case			:      Any        =			key or self.__key or 1

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

          # This will be returned
          snake_case			:      List[str]        =			""""""

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

          return ans







     def 			snake_case_      (				self							,__a							,__a = 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 			snake_case_      (				self							,__a							,__a							)      ->				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")



