



'''simple docstring'''




from typing import Any






class 		_UpperCamelCase						:


			'''simple docstring'''

			def __init__(							self  :				List[str]							,  lowerCAmelCase__  :				Any		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	List[Any]					 =	data
					__SCREAMING_SNAKE_CASE :	int					 =	None



			def __repr__(							self  :				Tuple		):





					"""simple docstring"""






					return F"Node({self.data})"






class 		_UpperCamelCase						:


			'''simple docstring'''

			def __init__(							self  :				Any		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	None

			def __iter__(							self  :				Any		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	self.head
					while node:
							yield node.data
							__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	node.next

			def __len__(							self  :				int		):





					"""simple docstring"""






					return sum(1 for _ in self		)

			def __repr__(							self  :				Union[str, Any]		):





					"""simple docstring"""






					return "->".join([str(lowerCAmelCase__		) for item in self]		)

			def __getitem__(							self  :				Union[str, Any]							,  lowerCAmelCase__  :				int		):





					"""simple docstring"""






					if not 0 <= index < len(self		):
							raise ValueError("""list index out of range."""		)
					for i, node in enumerate(self		):
							if i == index:
									return node
					return None

			def __setitem__(							self  :				Optional[Any]							,  lowerCAmelCase__  :				int							,  lowerCAmelCase__  :				Any		):





					"""simple docstring"""






					if not 0 <= index < len(self		):
							raise ValueError("""list index out of range."""		)
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	self.head
					for _ in range(lowerCAmelCase__		):
							__SCREAMING_SNAKE_CASE :	str					 =	current.next
					__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	data

			def UpperCamelCase__      (							self  :				Tuple							,  lowerCAmelCase__  :				Any		):





					"""simple docstring"""






					self.insert_nth(len(self		)							,  lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				List[str]							,  lowerCAmelCase__  :				Any		):





					"""simple docstring"""






					self.insert_nth(0							,  lowerCAmelCase__		)

			def UpperCamelCase__      (							self  :				int							,  lowerCAmelCase__  :				int							,  lowerCAmelCase__  :				Any		):





					"""simple docstring"""






					if not 0 <= index <= len(self		):
							raise IndexError("""list index out of range"""		)
					__SCREAMING_SNAKE_CASE :	str					 =	Node(lowerCAmelCase__		)
					if self.head is None:
							__SCREAMING_SNAKE_CASE :	Dict					 =	new_node
					elif index == 0:
							__SCREAMING_SNAKE_CASE :	str					 =	self.head  # link new_node to head
							__SCREAMING_SNAKE_CASE :	List[Any]					 =	new_node
					else:
							__SCREAMING_SNAKE_CASE :	List[str]					 =	self.head
							for _ in range(index - 1		):
									__SCREAMING_SNAKE_CASE :	Any					 =	temp.next
							__SCREAMING_SNAKE_CASE :	List[str]					 =	temp.next
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	new_node

			def UpperCamelCase__      (							self  :				Optional[int]		):  # print every node data





					"""simple docstring"""






					print(self		)

			def UpperCamelCase__      (							self  :				str		):





					"""simple docstring"""






					return self.delete_nth(0		)

			def UpperCamelCase__      (							self  :				List[str]		):  # delete from tail





					"""simple docstring"""






					return self.delete_nth(len(self		) - 1		)

			def UpperCamelCase__      (							self  :				Optional[int]							,  lowerCAmelCase__  :				int = 0		):





					"""simple docstring"""






					if not 0 <= index <= len(self		) - 1:  # test if index is valid
							raise IndexError("""List index out of range."""		)
					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	self.head  # default first node
					if index == 0:
							__SCREAMING_SNAKE_CASE :	Optional[int]					 =	self.head.next
					else:
							__SCREAMING_SNAKE_CASE :	Tuple					 =	self.head
							for _ in range(index - 1		):
									__SCREAMING_SNAKE_CASE :	int					 =	temp.next
							__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	temp.next
							__SCREAMING_SNAKE_CASE :	str					 =	temp.next.next
					return delete_node.data

			def UpperCamelCase__      (							self  :				List[Any]		):





					"""simple docstring"""






					return self.head is None



			def UpperCamelCase__      (							self  :				Any		):





					"""simple docstring"""






					__SCREAMING_SNAKE_CASE :	Optional[int]					 =	None
					__SCREAMING_SNAKE_CASE :	Dict					 =	self.head

					while current:
							# Store the current node's next node.
							__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	current.next
							# Make the current node's next point backwards
							__SCREAMING_SNAKE_CASE :	Dict					 =	prev
							# Make the previous node be the current node
							__SCREAMING_SNAKE_CASE :	Dict					 =	current
							# Make the current node the next node (to progress iteration)
							__SCREAMING_SNAKE_CASE :	Any					 =	next_node
					# Return prev in order to put the head at the end
					__SCREAMING_SNAKE_CASE :	Dict					 =	prev


def        lowerCAmelCase_     (			):
		__SCREAMING_SNAKE_CASE :	str					 =	LinkedList()
		assert linked_list.is_empty() is True
		assert str(_lowerCamelCase      ) == ""

		try:
				linked_list.delete_head()
				raise AssertionError  # This should not happen.
		except IndexError:
				assert True  # This should happen.

		try:
				linked_list.delete_tail()
				raise AssertionError  # This should not happen.
		except IndexError:
				assert True  # This should happen.

		for i in range(10      ):
				assert len(_lowerCamelCase      ) == i
				linked_list.insert_nth(_lowerCamelCase ,   i + 1      )
		assert str(_lowerCamelCase      ) == "->".join(str(_lowerCamelCase      ) for i in range(1 ,   11      )      )

		linked_list.insert_head(0      )
		linked_list.insert_tail(11      )
		assert str(_lowerCamelCase      ) == "->".join(str(_lowerCamelCase      ) for i in range(0 ,   12      )      )

		assert linked_list.delete_head() == 0
		assert linked_list.delete_nth(9      ) == 10
		assert linked_list.delete_tail() == 11
		assert len(_lowerCamelCase      ) == 9
		assert str(_lowerCamelCase      ) == "->".join(str(_lowerCamelCase      ) for i in range(1 ,   10      )      )

		assert all(linked_list[i] == i + 1 for i in range(0 ,   9      )      ) is True

		for i in range(0 ,   9      ):
				__SCREAMING_SNAKE_CASE :	Any					 =	-i
		assert all(linked_list[i] == -i for i in range(0 ,   9      )      ) is True

		linked_list.reverse()
		assert str(_lowerCamelCase      ) == "->".join(str(_lowerCamelCase      ) for i in range(-8 ,   1      )      )


def        lowerCAmelCase_     (			):
		__SCREAMING_SNAKE_CASE :	str					 =	[
		    -9,
		    1_00,
		    Node(77_34_51_12      ),
		    """dlrow olleH""",
		    7,
		    55_55,
		    0,
		    -1_92.5_55_55,
		    """Hello, world!""",
		    77.9,
		    Node(10      ),
		    None,
		    None,
		    12.20,
		]
		__SCREAMING_SNAKE_CASE :	int					 =	LinkedList()

		for i in test_input:
				linked_list.insert_tail(_lowerCamelCase      )

		# Check if it's empty or not
		assert linked_list.is_empty() is False
		assert (
		    str(_lowerCamelCase      ) == "-9->100->Node(77345112)->dlrow olleH->7->5555->0->"
		    "-192.55555->Hello, world!->77.9->Node(10)->None->None->12.2"
		)

		# Delete the head
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	linked_list.delete_head()
		assert result == -9
		assert (
		    str(_lowerCamelCase      ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
		    "Hello, world!->77.9->Node(10)->None->None->12.2"
		)

		# Delete the tail
		__SCREAMING_SNAKE_CASE :	Dict					 =	linked_list.delete_tail()
		assert result == 12.2
		assert (
		    str(_lowerCamelCase      ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
		    "Hello, world!->77.9->Node(10)->None->None"
		)

		# Delete a node in specific location in linked list
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	linked_list.delete_nth(10      )
		assert result is None
		assert (
		    str(_lowerCamelCase      ) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
		    "Hello, world!->77.9->Node(10)->None"
		)

		# Add a Node instance to its head
		linked_list.insert_head(Node("""Hello again, world!"""      )      )
		assert (
		    str(_lowerCamelCase      )
		    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
		    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None"
		)

		# Add None to its tail
		linked_list.insert_tail(_lowerCamelCase      )
		assert (
		    str(_lowerCamelCase      )
		    == "Node(Hello again, world!)->100->Node(77345112)->dlrow olleH->"
		    "7->5555->0->-192.55555->Hello, world!->77.9->Node(10)->None->None"
		)

		# Reverse the linked list
		linked_list.reverse()
		assert (
		    str(_lowerCamelCase      )
		    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
		    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
		)


def        lowerCAmelCase_     (			):
		from doctest import testmod

		testmod()

		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	LinkedList()
		linked_list.insert_head(input("""Inserting 1st at head """      ).strip()      )
		linked_list.insert_head(input("""Inserting 2nd at head """      ).strip()      )
		print("""\nPrint list:"""      )
		linked_list.print_list()
		linked_list.insert_tail(input("""\nInserting 1st at tail """      ).strip()      )
		linked_list.insert_tail(input("""Inserting 2nd at tail """      ).strip()      )
		print("""\nPrint list:"""      )
		linked_list.print_list()
		print("""\nDelete head"""      )
		linked_list.delete_head()
		print("""Delete tail"""      )
		linked_list.delete_tail()
		print("""\nPrint list:"""      )
		linked_list.print_list()
		print("""\nReverse linked list"""      )
		linked_list.reverse()
		print("""\nPrint list:"""      )
		linked_list.print_list()
		print("""\nString representation of linked list:"""      )
		print(_lowerCamelCase      )
		print("""\nReading/changing Node data using indexing:"""      )
		print(F"Element at Position 1: {linked_list[1]}"      )
		__SCREAMING_SNAKE_CASE :	Union[str, Any]					 =	input("""Enter New Value: """      ).strip()
		print("""New list:"""      )
		print(_lowerCamelCase      )
		print(F"length of linked_list is : {len(_lowerCamelCase      )}"      )


if __name__ == "__main__":
						main()




'''simple docstring'''




import qiskit


def        lowerCAmelCase_     (			_lowerCamelCase:     int = 2      ):
		__SCREAMING_SNAKE_CASE :	Dict					 =	qubits

		# Using Aer's simulator
		__SCREAMING_SNAKE_CASE :	Optional[Any]					 =	qiskit.Aer.get_backend("""aer_simulator"""      )

		# Creating a Quantum Circuit acting on the q register
		__SCREAMING_SNAKE_CASE :	str					 =	qiskit.QuantumCircuit(_lowerCamelCase ,   _lowerCamelCase      )

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

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

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

		# 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
		__SCREAMING_SNAKE_CASE :	str					 =	qiskit.execute(_lowerCamelCase ,   _lowerCamelCase ,   shots=10_00      )

		return job.result().get_counts(_lowerCamelCase      )


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