
from collections import Counter
from timeit import timeit


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


def      UpperCamelCase   (       __lowerCamelCase	:					str = ""       ):
       if len(__lowerCamelCase       ) == 0:
              return True
       snake_case			:  List[str]     							= 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			:  Any     							= character_freq_dict.get(__lowerCamelCase							,   0       ) + 1
       snake_case			:  Optional[int]     							= 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      UpperCamelCase   (       __lowerCamelCase	:					str = ""       ):
       print("\nFor string = "							,   __lowerCamelCase							,   ":"       )
       print(
           "> can_string_be_rearranged_as_palindrome_counter()"							,   "\tans ="							,   can_string_be_rearranged_as_palindrome_counter(__lowerCamelCase       )							,   "\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(__lowerCamelCase       )							,   "\ttime ="							,   timeit(
               "z.can_string_be_rearranged_as_palindrome(z.check_str)"							,   setup="import __main__ as z"							,   )							,   "seconds"							,   )


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







__lowerCamelCase				=			{
    0: """0""",
    1: """1""",
    2: """2""",
    3: """3""",
    4: """4""",
    5: """5""",
    6: """6""",
    7: """7""",
    8: """8""",
    9: """9""",
    10: """a""",
    11: """b""",
    12: """c""",
    13: """d""",
    14: """e""",
    15: """f""",
}


def      UpperCamelCase   (       __lowerCamelCase	:					float       ):
       assert type(__lowerCamelCase       ) in (int, float) and decimal == int(__lowerCamelCase       )
       snake_case			:  str     							= int(__lowerCamelCase       )
       snake_case			:  str     							= ""
       snake_case			:  str     							= False
       if decimal < 0:
              snake_case			:  Optional[Any]     							= True
              decimal *= -1
       while decimal > 0:
              snake_case							,   snake_case			:  Union[str, Any]     							= divmod(__lowerCamelCase							,   16       )
              snake_case			:  Tuple     							= values[remainder] + hexadecimal
       snake_case			:  Tuple     							= "0x" + hexadecimal
       if negative:
              snake_case			:  Any     							= "-" + hexadecimal
       return hexadecimal


if __name__ == "__main__":
   import doctest

   doctest.testmod()





