






import math

def        UpperCAmelCase__		(						lowerCamelCase_       :       list   ,  lowerCamelCase_       :       int = 0   ,  lowerCamelCase_       :       int = 0				):
			__a						:  List[str]									=     end or len(lowerCamelCase_				)
			for i in range(lowerCamelCase_   ,  lowerCamelCase_				):
						__a						:  str									=     i
						__a						:  int									=     array[i]
						while temp_index != start and temp_index_value < array[temp_index - 1]:
									__a						:  Dict									=     array[temp_index - 1]
									temp_index -= 1
						__a						:  List[Any]									=     temp_index_value
			return array

def        UpperCAmelCase__		(						lowerCamelCase_       :       list   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int				):  # Max Heap
			__a						:  Optional[int]									=     index
			__a						:  int									=     2 * index + 1  # Left Node
			__a						:  str									=     2 * index + 2  # Right Node

			if left_index < heap_size and array[largest] < array[left_index]:
						__a						:  Dict									=     left_index

			if right_index < heap_size and array[largest] < array[right_index]:
						__a						:  Tuple									=     right_index

			if largest != index:
						__a						,					__a						:  int									=     array[largest], array[index]
						heapify(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)

def        UpperCAmelCase__		(						lowerCamelCase_       :       list				):
			__a						:  Dict									=     len(lowerCamelCase_				)

			for i in range(n // 2   ,  -1   ,  -1				):
						heapify(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)

			for i in range(n - 1   ,  0   ,  -1				):
						__a						,					__a						:  Any									=     array[0], array[i]
						heapify(lowerCamelCase_   ,  0   ,  lowerCamelCase_				)

			return array

def        UpperCAmelCase__		(						lowerCamelCase_       :       list   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int				):
			if (array[first_index] > array[middle_index]) != (
			    array[first_index] > array[last_index]
			):
						return array[first_index]
			elif (array[middle_index] > array[first_index]) != (
			    array[middle_index] > array[last_index]
			):
						return array[middle_index]
			else:
						return array[last_index]

def        UpperCAmelCase__		(						lowerCamelCase_       :       list   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int				):
			__a						:  int									=     low
			__a						:  Tuple									=     high
			while True:
						while array[i] < pivot:
									i += 1
						j -= 1
						while pivot < array[j]:
									j -= 1
						if i >= j:
									return i
						__a						,					__a						:  int									=     array[j], array[i]
						i += 1

def        UpperCAmelCase__		(						lowerCamelCase_       :       list				):
			if len(lowerCamelCase_				) == 0:
						return array
			__a						:  List[str]									=     2 * math.ceil(math.loga(len(lowerCamelCase_				)				)				)
			__a						:  List[Any]									=     1_6
			return intro_sort(lowerCamelCase_   ,  0   ,  len(lowerCamelCase_				)   ,  lowerCamelCase_   ,  lowerCamelCase_				)

def        UpperCAmelCase__		(						lowerCamelCase_       :       list   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int   ,  lowerCamelCase_       :       int				):
			while end - start > size_threshold:
						if max_depth == 0:
									return heap_sort(lowerCamelCase_				)
						max_depth -= 1
						__a						:  Tuple									=     median_of_a(lowerCamelCase_   ,  lowerCamelCase_   ,  start + ((end - start) // 2) + 1   ,  end - 1				)
						__a						:  Union[str, Any]									=     partition(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)
						intro_sort(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)
						__a						:  Dict									=     p
			return insertion_sort(lowerCamelCase_   ,  lowerCamelCase_   ,  lowerCamelCase_				)


if __name__ == "__main__":
							import doctest

							doctest.testmod()

							SCREAMING_SNAKE_CASE__				     =			input('''Enter numbers separated by a comma : ''').strip()
							SCREAMING_SNAKE_CASE__				     =			[float(item) for item in user_input.split(''',''')]
							print(sort(unsorted))










'''simple docstring'''





import qiskit





def   a_   (		_UpperCAmelCase    :      int = 2				)    ->  qiskit.result.counts.Counts:
      __snake_case :   Union[str, Any]													=    qubits

      # Using Aer's simulator
      __snake_case :   List[Any]													=    qiskit.Aer.get_backend('aer_simulator'				)

      # Creating a Quantum Circuit acting on the q register
      __snake_case :   Dict													=    qiskit.QuantumCircuit(_UpperCAmelCase ,_UpperCAmelCase				)

      # Adding a H gate on qubit 0 (now q0 in superposition)
      circuit.h(0				)

      for i in range(1 ,_UpperCAmelCase				):
            # Adding CX (CNOT) gate
            circuit.cx(i - 1 ,_UpperCAmelCase				)

      # Mapping the quantum measurement to the classical bits
      circuit.measure(list(range(_UpperCAmelCase				)				) ,list(range(_UpperCAmelCase				)				)				)

      # Now measuring any one qubit would affect other qubits to collapse
      # their super position and have same state as the measured one.

      # Executing the circuit on the simulator
      __snake_case :   Optional[Any]													=    qiskit.execute(_UpperCAmelCase ,_UpperCAmelCase ,shots=10_00				)

      return job.result().get_counts(_UpperCAmelCase				)


if __name__ == "__main__":
    print(F"""Total count for various states are: {quantum_entanglement(3)}""")



