






from __future__ import annotations

from collections.abc import Iterable

class        _SCREAMING_SNAKE_CASE			:





	def __init__(						self							:   Union[str, Any]					,    __lowerCamelCase							:   Union[str, Any]					,    __lowerCamelCase							:   Optional[Any]      ):
		UpperCamelCase	, UpperCamelCase	:Union[str, Any]		=      float(__lowerCamelCase      ), float(__lowerCamelCase      )





	def __eq__(						self							:   Dict					,    __lowerCamelCase							:   List[Any]      ):
		return self.x == other.x and self.y == other.y





	def __ne__(						self							:   Tuple					,    __lowerCamelCase							:   Any      ):
		return not self == other





	def __gt__(						self							:   Dict					,    __lowerCamelCase							:   Any      ):
		if self.x > other.x:
			return True
		elif self.x == other.x:
			return self.y > other.y
		return False





	def __lt__(						self							:   Dict					,    __lowerCamelCase							:   Optional[Any]      ):
		return not self > other





	def __ge__(						self							:   Union[str, Any]					,    __lowerCamelCase							:   str      ):
		if self.x > other.x:
			return True
		elif self.x == other.x:
			return self.y >= other.y
		return False





	def __le__(						self							:   Union[str, Any]					,    __lowerCamelCase							:   Tuple      ):
		if self.x < other.x:
			return True
		elif self.x == other.x:
			return self.y <= other.y
		return False





	def __repr__(						self							:   int      ):
		return F"""({self.x}, {self.y})"""





	def __hash__(						self							:   Dict      ):
		return hash(self.x      )

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    list[Point] | list[list[float]] | Iterable[list[float]]      ,     )						->     list[Point]:






	"""simple docstring"""



	UpperCamelCase	:list[Point]		=      []
	if list_of_tuples:
		for p in list_of_tuples:
			if isinstance(__magic_name__      ,     __magic_name__   ):
				points.append(__magic_name__   )
			else:
				try:
					points.append(Point(p[0]      ,     p[1]   )   )
				except (IndexError, TypeError):
					print(
					    f"""Ignoring deformed point {p}. All points"""
					    """ must have at least 2 coordinates."""   )
	return points

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    list[Point] | list[list[float]]   )						->     list[Point]:






	"""simple docstring"""



	if not hasattr(__magic_name__      ,     """__iter__"""   ):
		UpperCamelCase	:int		=      f"""Expecting an iterable object but got an non-iterable type {points}"""
		raise ValueError(__magic_name__   )

	if not points:
		UpperCamelCase	:Dict		=      f"""Expecting a list of points but got {points}"""
		raise ValueError(__magic_name__   )

	return _construct_points(__magic_name__   )

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    Point      ,     __magic_name__   :    Point      ,     __magic_name__   :    Point   )						->     float:






	"""simple docstring"""



	UpperCamelCase	:str		=      (a.x * b.y + b.x * c.y + c.x * a.y) - (a.y * b.x + b.y * c.x + c.y * a.x)
	return det

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    list[Point]   )						->     list[Point]:






	"""simple docstring"""



	UpperCamelCase	:List[Any]		=      sorted(_validate_input(__magic_name__   )   )
	UpperCamelCase	:Optional[int]		=      len(__magic_name__   )
	UpperCamelCase	:Tuple		=      set()

	for i in range(n - 1   ):
		for j in range(i + 1      ,     __magic_name__   ):
			UpperCamelCase	:int		=      False
			UpperCamelCase	:Dict		=      True
			for k in range(__magic_name__   ):
				if k != i and k != j:
					UpperCamelCase	:List[str]		=      _det(points[i]      ,     points[j]      ,     points[k]   )

					if det_k > 0:
						UpperCamelCase	:Union[str, Any]		=      True
					elif det_k < 0:
						UpperCamelCase	:Optional[Any]		=      True
					else:
						# point[i], point[j], point[k] all lie on a straight line
						# if point[k] is to the left of point[i] or it's to the
						# right of point[j], then point[i], point[j] cannot be
						# part of the convex hull of A
						if points[k] < points[i] or points[k] > points[j]:
							UpperCamelCase	:int		=      False
							break

				if points_left_of_ij and points_right_of_ij:
					UpperCamelCase	:List[Any]		=      False
					break

			if ij_part_of_convex_hull:
				convex_set.update([points[i], points[j]]   )

	return sorted(__magic_name__   )

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    list[Point]   )						->     list[Point]:






	"""simple docstring"""



	UpperCamelCase	:List[str]		=      sorted(_validate_input(__magic_name__   )   )
	UpperCamelCase	:Tuple		=      len(__magic_name__   )

	# divide all the points into an upper hull and a lower hull
	# the left most point and the right most point are definitely
	# members of the convex hull by definition.
	# use these two anchors to divide all the points into two hulls,
	# an upper hull and a lower hull.

	# all points to the left (above) the line joining the extreme points belong to the
	# upper hull
	# all points to the right (below) the line joining the extreme points below to the
	# lower hull
	# ignore all points on the line joining the extreme points since they cannot be
	# part of the convex hull

	UpperCamelCase	:Any		=      points[0]
	UpperCamelCase	:Optional[Any]		=      points[n - 1]

	UpperCamelCase	:int		=      {left_most_point, right_most_point}
	UpperCamelCase	:int		=      []
	UpperCamelCase	:int		=      []

	for i in range(1      ,     n - 1   ):
		UpperCamelCase	:Any		=      _det(__magic_name__      ,     __magic_name__      ,     points[i]   )

		if det > 0:
			upper_hull.append(points[i]   )
		elif det < 0:
			lower_hull.append(points[i]   )

	_construct_hull(__magic_name__      ,     __magic_name__      ,     __magic_name__      ,     __magic_name__   )
	_construct_hull(__magic_name__      ,     __magic_name__      ,     __magic_name__      ,     __magic_name__   )

	return sorted(__magic_name__   )

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    list[Point]      ,     __magic_name__   :    Point      ,     __magic_name__   :    Point      ,     __magic_name__   :    set[Point]   )						->     None:






	"""simple docstring"""



	if points:
		UpperCamelCase	:Tuple		=      None
		UpperCamelCase	:Dict		=      float("""-inf"""   )
		UpperCamelCase	:Optional[int]		=      []

		for p in points:
			UpperCamelCase	:int		=      _det(__magic_name__      ,     __magic_name__      ,     __magic_name__   )

			if det > 0:
				candidate_points.append(__magic_name__   )

				if det > extreme_point_distance:
					UpperCamelCase	:Optional[int]		=      det
					UpperCamelCase	:List[Any]		=      p

		if extreme_point:
			_construct_hull(__magic_name__      ,     __magic_name__      ,     __magic_name__      ,     __magic_name__   )
			convex_set.add(__magic_name__   )
			_construct_hull(__magic_name__      ,     __magic_name__      ,     __magic_name__      ,     __magic_name__   )

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    list[Point]   )						->     list[Point]:






	"""simple docstring"""



	UpperCamelCase	:Optional[Any]		=      sorted(_validate_input(__magic_name__   )   )
	UpperCamelCase	:List[str]		=      len(__magic_name__   )

	UpperCamelCase	:Any		=      points[:2]
	for i in range(2      ,     __magic_name__   ):
		UpperCamelCase	:List[Any]		=      _det(convex_hull[1]      ,     convex_hull[0]      ,     points[i]   )
		if det > 0:
			convex_hull.insert(0      ,     points[i]   )
			break
		elif det < 0:
			convex_hull.append(points[i]   )
			break
		else:
			UpperCamelCase	:List[str]		=      points[i]
	i += 1

	for j in range(__magic_name__      ,     __magic_name__   ):
		if (
		    _det(convex_hull[0]      ,     convex_hull[-1]      ,     points[j]   ) > 0
		    and _det(convex_hull[-1]      ,     convex_hull[0]      ,     points[1]   ) < 0
		):
			# The point lies within the convex hull
			continue

		convex_hull.insert(0      ,     points[j]   )
		convex_hull.append(points[j]   )
		while _det(convex_hull[0]      ,     convex_hull[1]      ,     convex_hull[2]   ) >= 0:
			del convex_hull[1]
		while _det(convex_hull[-1]      ,     convex_hull[-2]      ,     convex_hull[-3]   ) <= 0:
			del convex_hull[-2]

    # `convex_hull` is contains the convex hull in circular order
	return sorted(convex_hull[1:] if len(__magic_name__   ) > 3 else convex_hull   )

def   SCREAMING_SNAKE_CASE_				(				)						->     List[str]:






	"""simple docstring"""



	UpperCamelCase	:List[str]		=      [
	    (0, 3),
	    (2, 2),
	    (1, 1),
	    (2, 1),
	    (3, 0),
	    (0, 0),
	    (3, 3),
	    (2, -1),
	    (2, -4),
	    (1, -3),
	]
	# the convex set of points is
	# [(0, 0), (0, 3), (1, -3), (2, -4), (3, 0), (3, 3)]
	UpperCamelCase	:int		=      convex_hull_bf(__magic_name__   )

	UpperCamelCase	:int		=      convex_hull_recursive(__magic_name__   )
	assert results_bf == results_recursive

	UpperCamelCase	:Optional[Any]		=      convex_hull_melkman(__magic_name__   )
	assert results_bf == results_melkman

	print(__magic_name__   )


if __name__ == "__main__":
	main()








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

def   SCREAMING_SNAKE_CASE_				(				__magic_name__   :    float = np.pi / 2      ,     __magic_name__   :    float = np.pi / 2      ,     __magic_name__   :    float = np.pi / 2   )						->     qiskit.result.counts.Counts:






	"""simple docstring"""



	UpperCamelCase	:Optional[int]		=      QuantumRegister(3      ,     """qr"""   )  # Define the number of quantum bits
	UpperCamelCase	:Optional[Any]		=      ClassicalRegister(1      ,     """cr"""   )  # Define the number of classical bits

	UpperCamelCase	:List[Any]		=      QuantumCircuit(__magic_name__      ,     __magic_name__   )  # Define the quantum circuit.

	# Build the circuit
	quantum_circuit.u(__magic_name__      ,     __magic_name__      ,     __magic_name__      ,     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	:Union[str, Any]		=      Aer.get_backend("""aer_simulator"""   )
	UpperCamelCase	:Dict		=      execute(__magic_name__      ,     __magic_name__      ,     shots=1000   )

	return job.result().get_counts(__magic_name__   )


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