





class   a_ :

			def __init__(   self   :  Optional[int]						):






							"""simple docstring"""
							snake_case   :					Optional[Any]    						=				0
							snake_case   :					List[Any]    						=				0
							snake_case   :					int    						=				{}

			def      lowerCAmelCase(   self   :  List[Any]     , UpperCAmelCase__   :  str						):






							"""simple docstring"""

							if vertex not in self.adjacency:
											snake_case   :					Any    						=				{}
											self.num_vertices += 1

			def      lowerCAmelCase(   self   :  Any     , UpperCAmelCase__   :  int     , UpperCAmelCase__   :  Dict     , UpperCAmelCase__   :  List[str]						):






							"""simple docstring"""
							self.add_vertex(snake_case_						)
							self.add_vertex(snake_case_						)

							if head == tail:
											return

							snake_case   :					Tuple    						=				weight
							snake_case   :					Tuple    						=				weight

			def      lowerCAmelCase(   self   :  Dict						):






							"""simple docstring"""
							snake_case   :					Any    						=				self.get_edges()
							for edge in edges:
											snake_case						,						snake_case						,						snake_case   :					List[Any]    						=				edge
											edges.remove((tail, head, weight)						)
							for i in range(len(snake_case_						)						):
											snake_case   :					str    						=				list(edges[i]						)

							edges.sort(key=lambda UpperCAmelCase__						: e[2]						)
							for i in range(len(snake_case_						) - 1						):
											if edges[i][2] >= edges[i + 1][2]:
															snake_case   :					Optional[Any]    						=				edges[i][2] + 1
							for edge in edges:
											snake_case						,						snake_case						,						snake_case   :					Union[str, Any]    						=				edge
											snake_case   :					Dict    						=				weight
											snake_case   :					Optional[int]    						=				weight

			def __str__(   self   :  Union[str, Any]						):






							"""simple docstring"""
							snake_case   :					Optional[int]    						=				''''''
							for tail in self.adjacency:
											for head in self.adjacency[tail]:
															snake_case   :					List[str]    						=				self.adjacency[head][tail]
															string += F"{head} -> {tail} == {weight}\n"
							return string.rstrip('''\n'''						)

			def      lowerCAmelCase(   self   :  List[str]						):






							"""simple docstring"""
							snake_case   :					str    						=				[]
							for tail in self.adjacency:
											for head in self.adjacency[tail]:
															output.append((tail, head, self.adjacency[head][tail])						)
							return output

			def      lowerCAmelCase(   self   :  List[str]						):






							"""simple docstring"""
							return self.adjacency.keys()

			@staticmethod
			def      lowerCAmelCase(   UpperCAmelCase__   :  Union[str, Any]=None     , UpperCAmelCase__   :  int=None						):






							"""simple docstring"""
							snake_case   :					Union[str, Any]    						=				Graph()
							if vertices is None:
											snake_case   :					str    						=				[]
							if edges is None:
											snake_case   :					Optional[Any]    						=				[]
							for vertex in vertices:
											g.add_vertex(snake_case_						)
							for edge in edges:
											g.add_edge(*snake_case_						)
							return g
			class   a_ :

						def __init__(   self   :  Dict						):






										"""simple docstring"""
										snake_case   :					str    						=				{}
										snake_case   :					Optional[int]    						=				{}

						def __len__(   self   :  Any						):






										"""simple docstring"""
										return len(self.parent						)

						def      lowerCAmelCase(   self   :  List[Any]     , UpperCAmelCase__   :  List[str]						):






										"""simple docstring"""

										if item in self.parent:
														return self.find(snake_case_						)

										snake_case   :					Union[str, Any]    						=				item
										snake_case   :					Optional[int]    						=				0
										return item

						def      lowerCAmelCase(   self   :  Any     , UpperCAmelCase__   :  List[str]						):






										"""simple docstring"""

										if item not in self.parent:
														return self.make_set(snake_case_						)
										if item != self.parent[item]:
														snake_case   :					Any    						=				self.find(self.parent[item]						)
										return self.parent[item]



						def      lowerCAmelCase(   self   :  Optional[int]     , UpperCAmelCase__   :  str     , UpperCAmelCase__   :  Any						):






										"""simple docstring"""
										snake_case   :					Any    						=				self.find(snake_case_						)
										snake_case   :					Any    						=				self.find(snake_case_						)

										if roota == roota:
														return roota

										if self.rank[roota] > self.rank[roota]:
														snake_case   :					Optional[int]    						=				roota
														return roota

										if self.rank[roota] < self.rank[roota]:
														snake_case   :					Any    						=				roota
														return roota

										if self.rank[roota] == self.rank[roota]:
														self.rank[roota] += 1
														snake_case   :					Union[str, Any]    						=				roota
														return roota
										return None

			@staticmethod
			def      lowerCAmelCase(   UpperCAmelCase__   :  Dict						):






							"""simple docstring"""
							snake_case   :					str    						=				graph.num_vertices

							snake_case   :					List[Any]    						=				Graph.UnionFind()
							snake_case   :					str    						=				[]
							while num_components > 1:
											snake_case   :					int    						=				{}
											for vertex in graph.get_vertices():
															snake_case   :					Optional[int]    						=				-1

											snake_case   :					int    						=				graph.get_edges()
											for edge in edges:
															snake_case						,						snake_case						,						snake_case   :					List[Any]    						=				edge
															edges.remove((tail, head, weight)						)
											for edge in edges:
															snake_case						,						snake_case						,						snake_case   :					Union[str, Any]    						=				edge
															snake_case   :					Optional[int]    						=				union_find.find(snake_case_						)
															snake_case   :					Optional[int]    						=				union_find.find(snake_case_						)
															if seta != seta:
																			if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
																							snake_case   :					str    						=				[head, tail, weight]

																			if cheap_edge[seta] == -1 or cheap_edge[seta][2] > weight:
																							snake_case   :					Tuple    						=				[head, tail, weight]
											for vertex in cheap_edge:
															if cheap_edge[vertex] != -1:
																			snake_case						,						snake_case						,						snake_case   :					Optional[int]    						=				cheap_edge[vertex]
																			if union_find.find(snake_case_						) != union_find.find(snake_case_						):
																							union_find.union(snake_case_     , snake_case_						)
																							mst_edges.append(cheap_edge[vertex]						)
																							snake_case   :					Dict    						=				num_components - 1
							snake_case   :					int    						=				Graph.build(edges=snake_case_						)
							return mst




from collections import Counter
from timeit import timeit


def 		lowercase_	(  _UpperCamelCase = ""							,      ):


			'''simple docstring'''







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


def 		lowercase_	(  _UpperCamelCase = ""	):


			'''simple docstring'''







			if len(_UpperCamelCase	) == 0:
						return True
			__lowercase			       = input_str.replace(''' '''							,      ''''''	).lower()
			# character_freq_dict: Stores the frequency of every character in the input string
			__lowercase			       = {}

			for character in lower_case_input_str:
						__lowercase			       = character_freq_dict.get(_UpperCamelCase							,      0	) + 1
			__lowercase			       = 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 		lowercase_	(  _UpperCamelCase = ""	):


			'''simple docstring'''







			print('''\nFor string = '''							,      _UpperCamelCase							,      ''':'''	)
			print(
			    '''> can_string_be_rearranged_as_palindrome_counter()'''							,      '''\tans ='''							,      can_string_be_rearranged_as_palindrome_counter(_UpperCamelCase	)							,      '''\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(_UpperCamelCase	)							,      '''\ttime ='''							,      timeit(
			        '''z.can_string_be_rearranged_as_palindrome(z.check_str)'''							,      setup='''import __main__ as z'''							,      )							,      '''seconds'''							,      )


if __name__ == "__main__":
	a			:			int												=					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''')


