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






def      UpperCamelCase_				(      A__						):
	a_      				=						""""""
	try:
		with open(A__  ,      """rb"""						) as binary_file:
			a_      				=						binary_file.read()
		for dat in data:
			a_      				=						F'''{dat:08b}'''
			result += curr_byte
		return result
	except OSError:
		print("""File not accessible"""						)
		sys.exit()






def      UpperCamelCase_				(      A__						):
	a_      				=						{"""0""": """0""", """1""": """1"""}
	a_      				=						"""""", """"""
	a_      				=						len(A__						)

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

		a_      				=						lexicon[curr_string]
		result += last_match_id
		a_      				=						last_match_id + """0"""

		if math.loga(A__						).is_integer():
			a_      				=						{}
			for curr_key in list(A__						):
				a_      				=						lexicon.pop(A__						)
			a_      				=						new_lex

		a_      				=						last_match_id + """1"""
		index += 1
		a_      				=						""""""
	return result






def      UpperCamelCase_				(      A__  ,      A__						):
	a_      				=						8
	try:
		with open(A__  ,      """wb"""						) as opened_file:
			a_      				=						[
			    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[:-1]:
				opened_file.write(int(A__  ,      2						).to_bytes(1  ,      byteorder="""big"""						)						)
	except OSError:
		print("""File not accessible"""						)
		sys.exit()






def      UpperCamelCase_				(      A__						):
	a_      				=						0
	for letter in data_bits:
		if letter == "1":
			break
		counter += 1

	a_      				=						data_bits[counter:]
	a_      				=						data_bits[counter + 1 :]
	return data_bits






def      UpperCamelCase_				(      A__  ,      A__						):
	a_      				=						read_file_binary(A__						)
	a_      				=						remove_prefix(A__						)
	a_      				=						decompress_data(A__						)
	write_file_binary(A__  ,      A__						)


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







import qiskit





def  __magic_name__  (				lowercase				,       lowercase				)				-> qiskit.result.counts.Counts:

							"""simple docstring"""



							lowercase_	:   Dict  				=     qiskit.Aer.get_backend("""aer_simulator"""				)

							# Create a Quantum Circuit acting on the q register
							lowercase_	:   str  				=     qiskit.QuantumCircuit(lowercase				,       lowercase				)

							# Map the quantum measurement to the classical bits
							circuit.measure([0]				,       [0]				)

							# Execute the circuit on the simulator
							lowercase_	:   List[Any]  				=     qiskit.execute(lowercase				,       lowercase				,       shots=1000				)

							# Return the histogram data of the results of the experiment.
							return job.result().get_counts(lowercase				)


if __name__ == "__main__":
							print(F'''Total count for various states are: {single_qubit_measure(1, 1)}''')