






from typing import Any




class 		UpperCAmelCase_						:


						'''simple docstring'''




						def __init__(	self		,				_SCREAMING_SNAKE_CASE				) ->				Optional[Any]:
								snake_case_				:							Dict						 =       data
								snake_case_				:							Tuple						 =       None






						def __repr__(	self				) ->				str:
								return f'''Node({self.data})'''




class 		UpperCAmelCase_						:


						'''simple docstring'''




						def __init__(	self				) ->				Optional[Any]:
								snake_case_				:							str						 =       None






						def __iter__(	self				) ->				Any:
								snake_case_				:							Optional[int]						 =       self.head
								while node:
										yield node.data
										snake_case_				:							Optional[Any]						 =       node.next






						def __len__(	self				) ->				int:
								return sum(1 for _ in self				)






						def __repr__(	self				) ->				str:
								return "->".join([str(_SCREAMING_SNAKE_CASE				) for item in self]				)






						def __getitem__(	self		,				_SCREAMING_SNAKE_CASE				) ->				Any:
								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		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) ->				None:
								if not 0 <= index < len(self				):
										raise ValueError("list index out of range."				)
								snake_case_				:							Any						 =       self.head
								for _ in range(_SCREAMING_SNAKE_CASE				):
										snake_case_				:							List[Any]						 =       current.next
								snake_case_				:							Union[str, Any]						 =       data






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				None:
								self.insert_nth(len(self				)		,				_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE				) ->				None:
								self.insert_nth(0		,				_SCREAMING_SNAKE_CASE				)






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






						def       _lowerCAmelCase       (	self				) ->				None:  # print every node data
								print(self				)






						def       _lowerCAmelCase       (	self				) ->				Any:
								return self.delete_nth(0				)






						def       _lowerCAmelCase       (	self				) ->				Any:  # delete from tail
								return self.delete_nth(len(self				) - 1				)






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






						def       _lowerCAmelCase       (	self				) ->				bool:
								return self.head is None






						def       _lowerCAmelCase       (	self				) ->				None:
								snake_case_				:							Dict						 =       None
								snake_case_				:							List[Any]						 =       self.head

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




def      lowerCAmelCase__	(    ):
		snake_case_				:							List[str]						 =       LinkedList()
		assert linked_list.is_empty() is True
		assert str(_a    ) == ""

		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(_a    ) == i
				linked_list.insert_nth(_a  ,      i + 1    )
		assert str(_a    ) == "->".join(str(_a    ) for i in range(1  ,      11    )    )

		linked_list.insert_head(0    )
		linked_list.insert_tail(11    )
		assert str(_a    ) == "->".join(str(_a    ) 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(_a    ) == 9
		assert str(_a    ) == "->".join(str(_a    ) 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    ):
				snake_case_				:							Union[str, Any]						 =       -i
		assert all(linked_list[i] == -i for i in range(0  ,      9    )    ) is True

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

def      lowerCAmelCase__	(    ):
		snake_case_				:							Union[str, Any]						 =       [
		    -9,
		    1_00,
		    Node(77_34_51_12    ),
		    "dlrow olleH",
		    7,
		    55_55,
		    0,
		    -192.55_555,
		    "Hello, world!",
		    77.9,
		    Node(10    ),
		    None,
		    None,
		    12.20,
		]
		snake_case_				:							Tuple						 =       LinkedList()

		for i in test_input:
				linked_list.insert_tail(_a    )

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

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

		# Delete the tail
		snake_case_				:							int						 =       linked_list.delete_tail()
		assert result == 12.2
		assert (
		    str(_a    ) == "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
		snake_case_				:							Any						 =       linked_list.delete_nth(10    )
		assert result is None
		assert (
		    str(_a    ) == "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(_a    )
		    == "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(_a    )
		assert (
		    str(_a    )
		    == "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(_a    )
		    == "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()

		snake_case_				:							int						 =       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(_a    )
		print("\nReading/changing Node data using indexing:"    )
		print(F'''Element at Position 1: {linked_list[1]}'''    )
		snake_case_				:							List[str]						 =       input("Enter New Value: "    ).strip()
		print("New list:"    )
		print(_a    )
		print(F'''length of linked_list is : {len(_a    )}'''    )


if __name__ == "__main__":
							main()








def      lowerCAmelCase__	(    _a       :			str  ,      _a       :			int    ):
		# "extended trapezoidal rule"
		# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
		snake_case_				:							Optional[Any]						 =       (boundary[1] - boundary[0]) / steps
		snake_case_				:							str						 =       boundary[0]
		snake_case_				:							Dict						 =       boundary[1]
		snake_case_				:							str						 =       make_points(_a  ,      _a  ,      _a    )
		snake_case_				:							str						 =       0.0
		y += (h / 2.0) * f(_a    )
		for i in x_i:
				# print(i)
				y += h * f(_a    )
		y += (h / 2.0) * f(_a    )
		return y

def      lowerCAmelCase__	(    _a       :			str  ,      _a       :			Optional[Any]  ,      _a       :			Tuple    ):
		snake_case_				:							Tuple						 =       a + h
		while x < (b - h):
				yield x
				snake_case_				:							List[str]						 =       x + h

def      lowerCAmelCase__	(    _a       :			Tuple    ):  # enter your function here
		snake_case_				:							Tuple						 =       (x - 0) * (x - 0)
		return y

def      lowerCAmelCase__	(    ):
		snake_case_				:							Union[str, Any]						 =       0.0  # Lower bound of integration
		snake_case_				:							List[Any]						 =       1.0  # Upper bound of integration
		snake_case_				:							Tuple						 =       10.0  # define number of steps or resolution
		snake_case_				:							List[Any]						 =       [a, b]  # define boundary of integration
		snake_case_				:							Any						 =       method_a(_a  ,      _a    )
		print(F'''y = {y}'''    )


if __name__ == "__main__":
							main()
