import numpy as np
import qiskit
from qiskit import Aer, ClassicalRegister, QuantumCircuit, QuantumRegister, execute






def     lowerCamelCase_ (			UpperCamelCase__    :		List[Any] = np.pi / 2,						UpperCamelCase__    :		Tuple = np.pi / 2,						UpperCamelCase__    :		int = np.pi / 2       ):







				'''simple docstring'''







				UpperCamelCase__       						=							QuantumRegister(3,						'''qr'''       )  # Define the number of quantum bits
				UpperCamelCase__       						=							ClassicalRegister(1,						'''cr'''       )  # Define the number of classical bits

				UpperCamelCase__       						=							QuantumCircuit(UpperCamelCase__,						UpperCamelCase__       )  # Define the quantum circuit.

				# Build the circuit
				quantum_circuit.u(UpperCamelCase__,						UpperCamelCase__,						UpperCamelCase__,						0       )  # Quantum State to teleport
				quantum_circuit.h(1       )  # add hadamard gate
				quantum_circuit.cx(
				    1,						2       )  # add control gate with qubit 1 as control and 2 as target.
				quantum_circuit.cx(0,						1       )
				quantum_circuit.h(0       )
				quantum_circuit.cz(0,						2       )  # add control z gate.
				quantum_circuit.cx(1,						2       )

				quantum_circuit.measure([2],						[0]       )  # measure the qubit.

				# Simulate the circuit using qasm simulator
				UpperCamelCase__       						=							Aer.get_backend('''aer_simulator'''       )
				UpperCamelCase__       						=							execute(UpperCamelCase__,						UpperCamelCase__,						shots=1000       )

				return job.result().get_counts(UpperCamelCase__       )


if __name__ == "__main__":
		print(
		    """Total count for teleported state is: """
		    f'{quantum_teleportation(np.pi/2, np.pi/2, np.pi/2)}'
		)





def 				A__    (  lowerCamelCase  )     ->		Optional[Any]:
				UpperCamelCase_:							Optional[int]		=  len(lowerCamelCase  )
				for _ in range(
				    0   ,			int(((no_of_elements - 1) / 2) + 1  )  ):  # we don't need to traverse to end of list as
								for j in range(0   ,			no_of_elements - 1  ):
												if (
												    lst[j + 1] < lst[j]
												):  # applying bubble sort algorithm from left to right (or forwards)
																UpperCamelCase_:							str		=  lst[j + 1]
																UpperCamelCase_:							Tuple		=  lst[j]
																UpperCamelCase_:							str		=  temp
												if (
												    lst[no_of_elements - 1 - j] < lst[no_of_elements - 2 - j]
												):  # applying bubble sort algorithm from right to left (or backwards)
																UpperCamelCase_:							Union[str, Any]		=  lst[no_of_elements - 1 - j]
																UpperCamelCase_:							Dict		=  lst[no_of_elements - 2 - j]
																UpperCamelCase_:							List[Any]		=  temp
				return lst


if __name__ == "__main__":
							print("""enter the list to be sorted""")
							lowerCamelCase_  :       Union[str, Any]					      =     [int(x) for x in input().split()]  # inputing elements of the list in one line
							lowerCamelCase_  :       Union[str, Any]					      =     double_sort(lst)
							print("""the sorted list is""")
							print(sorted_lst)






