


'''simple docstring'''






import logging
import os
from logging import (
    CRITICAL,  # NOQA
    DEBUG,  # NOQA
    ERROR,  # NOQA
    FATAL,  # NOQA
    INFO,  # NOQA
    NOTSET,  # NOQA
    WARN,  # NOQA
    WARNING,  # NOQA
)
from typing import Optional

from tqdm import auto as tqdm_lib


__UpperCAmelCase					       =							{
    '''debug''': logging.DEBUG,
    '''info''': logging.INFO,
    '''warning''': logging.WARNING,
    '''error''': logging.ERROR,
    '''critical''': logging.CRITICAL,
}

__UpperCAmelCase					       =							logging.WARNING


def       _snake_case     (  )		->					Optional[Any]:
							lowerCAmelCase__      =			os.getenv('''DATASETS_VERBOSITY'''				,					A )
							if env_level_str:
														if env_level_str in log_levels:
																					return log_levels[env_level_str]
														else:
																					logging.getLogger().warning(
																					    F"""Unknown option DATASETS_VERBOSITY={env_level_str}, """
																					    F"""has to be one of: { ", ".join(log_levels.keys() ) }""" )
							return _default_log_level


def       _snake_case     (  )		->					str:
							return __name__.split('''.''' )[0]


def       _snake_case     (  )		->					logging.Logger:
							return logging.getLogger(_get_library_name() )


def       _snake_case     (  )		->					None:
							# Apply our default configuration to the library root logger.
							lowerCAmelCase__      =			_get_library_root_logger()
							library_root_logger.setLevel(_get_default_logging_level() )


def       _snake_case     (  )		->					None:
							lowerCAmelCase__      =			_get_library_root_logger()
							library_root_logger.setLevel(logging.NOTSET )


def       _snake_case     (  A = None )		->					logging.Logger:
							if name is None:
														lowerCAmelCase__      =			_get_library_name()
							return logging.getLogger(A )


def       _snake_case     (  )		->					int:
							return _get_library_root_logger().getEffectiveLevel()


def       _snake_case     (  A )		->					None:
							_get_library_root_logger().setLevel(A )


def       _snake_case     (  )		->					Optional[int]:
							return set_verbosity(A )


def       _snake_case     (  )		->					Union[str, Any]:
							return set_verbosity(A )


def       _snake_case     (  )		->					Any:
							return set_verbosity(A )


def       _snake_case     (  )		->					Union[str, Any]:
							return set_verbosity(A )


def       _snake_case     (  )		->					None:
							lowerCAmelCase__      =			False


def       _snake_case     (  )		->					None:
							lowerCAmelCase__      =			True


# Configure the library root logger at the module level (singleton-like)
_configure_library_root_logger()




class 	a__       :





							'''simple docstring'''






							def __init__(	self      ,					*lowerCamelCase_      ,					**lowerCamelCase_     ) ->							int:  # pylint: disable=unused-argument
														lowerCAmelCase__      =			args[0] if args else None







							def __iter__(	self     ) ->							Any:
														return iter(self._iterator     )







							def __getattr__(	self      ,					lowerCamelCase_     ) ->							Dict:

														def empty_fn(*lowerCamelCase_      ,					**lowerCamelCase_     ):  # pylint: disable=unused-argument
																					return

														return empty_fn







							def __enter__(	self     ) ->							List[Any]:
														return self







							def __exit__(	self      ,					lowerCamelCase_      ,					lowerCamelCase_      ,					lowerCamelCase_     ) ->							str:
														return

__UpperCAmelCase					       =							True




class 	a__       :





							'''simple docstring'''






							def __call__(	self      ,					*lowerCamelCase_      ,					lowerCamelCase_=False      ,					**lowerCamelCase_     ) ->							Optional[int]:
														if _tqdm_active and not disable:
																					return tqdm_lib.tqdm(*lowerCamelCase_      ,					**lowerCamelCase_     )
														else:
																					return EmptyTqdm(*lowerCamelCase_      ,					**lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self      ,					*lowerCamelCase_      ,					**lowerCamelCase_     ) ->							Dict:
														lowerCAmelCase__      =			None
														if _tqdm_active:
																					return tqdm_lib.tqdm.set_lock(*lowerCamelCase_      ,					**lowerCamelCase_     )







							def 						__SCREAMING_SNAKE_CASE							(	self     ) ->							Any:
														if _tqdm_active:
																					return tqdm_lib.tqdm.get_lock()

__UpperCAmelCase					       =							_tqdm_cls()


def       _snake_case     (  )		->					bool:
							global _tqdm_active
							return bool(_tqdm_active )


def       _snake_case     (  )		->					Dict:
							global _tqdm_active
							lowerCAmelCase__      =			True






def       _snake_case     (  )		->					Union[str, Any]:
							global _tqdm_active
							lowerCAmelCase__      =			False



'''simple docstring'''






from collections import Counter
from timeit import timeit


def       _snake_case     (  A = ""				,					)		->					bool:
							return sum(c % 2 for c in Counter(input_str.replace(''' '''				,					'''''' ).lower() ).values() ) < 2


def       _snake_case     (  A = "" )		->					bool:
							if len(A ) == 0:
														return True
							lowerCAmelCase__      =			input_str.replace(''' '''				,					'''''' ).lower()
							# character_freq_dict: Stores the frequency of every character in the input string
							lowerCAmelCase__      =			{}

							for character in lower_case_input_str:
														lowerCAmelCase__      =			character_freq_dict.get(A				,					0 ) + 1
							lowerCAmelCase__      =			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       _snake_case     (  A = "" )		->					None:
							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__":
		__UpperCAmelCase					       =							input(
		    '''Enter string to determine if it can be rearranged as a palindrome or not: '''
		).strip()
		benchmark(check_str)
		__UpperCAmelCase					       =							can_string_be_rearranged_as_palindrome_counter(check_str)
		print(f"""{check_str} can {'' if status else 'not '}be rearranged as a palindrome""")