


'''simple docstring'''
import math
import os
import sys


def       a				(      __a       )  ->     str:



					'''simple docstring'''






					UpperCamelCase__       :Optional[Any]							 =			''''''
					try:
										with open(__a			, '''rb'''       ) as binary_file:
															UpperCamelCase__       :Optional[Any]							 =			binary_file.read()
										for dat in data:
															UpperCamelCase__       :str							 =			f'''{dat:08b}'''
															result += curr_byte
										return result
					except OSError:
										print('''File not accessible'''       )
										sys.exit()


def       a				(      __a			, __a			, __a			, __a       )  ->     None:



					'''simple docstring'''






					lexicon.pop(__a       )
					UpperCamelCase__       :Optional[int]							 =			last_match_id

					if math.loga(__a       ).is_integer():
										for curr_key in lexicon:
															UpperCamelCase__       :Optional[int]							 =			'''0''' + lexicon[curr_key]

					UpperCamelCase__       :str							 =			bin(__a       )[2:]


def       a				(      __a       )  ->     str:



					'''simple docstring'''






					UpperCamelCase__       :Optional[Any]							 =			{'''0''': '''0''', '''1''': '''1'''}
					UpperCamelCase__ ,    UpperCamelCase__       :int							 =			'''''', ''''''
					UpperCamelCase__       :int							 =			len(__a       )

					for i in range(len(__a       )       ):
										curr_string += data_bits[i]
										if curr_string not in lexicon:
															continue

										UpperCamelCase__       :Dict							 =			lexicon[curr_string]
										result += last_match_id
										add_key_to_lexicon(__a			, __a			, __a			, __a       )
										index += 1
										UpperCamelCase__       :int							 =			''''''

					while curr_string != "" and curr_string not in lexicon:
										curr_string += "0"

					if curr_string != "":
										UpperCamelCase__       :List[str]							 =			lexicon[curr_string]
										result += last_match_id

					return result


def       a				(      __a			, __a       )  ->     str:



					'''simple docstring'''






					UpperCamelCase__       :Dict							 =			os.path.getsize(__a       )
					UpperCamelCase__       :List[str]							 =			bin(__a       )[2:]
					UpperCamelCase__       :Union[str, Any]							 =			len(__a       )

					return "0" * (length_length - 1) + file_length_binary + compressed


def       a				(      __a			, __a       )  ->     None:



					'''simple docstring'''






					UpperCamelCase__       :Any							 =			8
					try:
										with open(__a			, '''wb'''       ) as opened_file:
															UpperCamelCase__       :str							 =			[
															    to_write[i : i + byte_length]
															    for i in range(0			, len(__a       )			, __a       )
															]

															if len(result_byte_array[-1]       ) % byte_length == 0:
																				result_byte_array.append('''10000000'''       )
															else:
																				result_byte_array[-1] += "1" + "0" * (
																				    byte_length - len(result_byte_array[-1]       ) - 1
																				)

															for elem in result_byte_array:
																				opened_file.write(int(__a			, 2       ).to_bytes(1			, byteorder='''big'''       )       )
					except OSError:
										print('''File not accessible'''       )
										sys.exit()


def       a				(      __a			, __a       )  ->     None:



					'''simple docstring'''






					UpperCamelCase__       :int							 =			read_file_binary(__a       )
					UpperCamelCase__       :Optional[Any]							 =			compress_data(__a       )
					UpperCamelCase__       :Any							 =			add_file_length(__a			, __a       )
					write_file_binary(__a			, __a       )


if __name__ == "__main__":
		compress(sys.argv[1], sys.argv[2])



'''simple docstring'''
from collections import Counter
from timeit import timeit


def       a				(      __a = ""			, )  ->     bool:



					'''simple docstring'''






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


def       a				(      __a = ""       )  ->     bool:



					'''simple docstring'''






					if len(__a       ) == 0:
										return True
					UpperCamelCase__       :List[Any]							 =			input_str.replace(''' '''			, ''''''       ).lower()
					# character_freq_dict: Stores the frequency of every character in the input string
					UpperCamelCase__       :dict[str, int]							 =			{}

					for character in lower_case_input_str:
										UpperCamelCase__       :Optional[int]							 =			character_freq_dict.get(__a			, 0       ) + 1
					UpperCamelCase__       :List[str]							 =			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       a				(      __a = ""       )  ->     None:



					'''simple docstring'''






					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__":
		__snake_case											=					input(
		    '''Enter string to determine if it can be rearranged as a palindrome or not: '''
		).strip()
		benchmark(check_str)
		__snake_case											=					can_string_be_rearranged_as_palindrome_counter(check_str)
		print(F"""{check_str} can {'' if status else 'not '}be rearranged as a palindrome""")