

"""simple docstring"""






snake_case_   :   str        =       {
    """Pillow""": """Pillow<10.0.0""",
    """accelerate""": """accelerate>=0.20.3""",
    """av""": """av==9.2.0""",
    """beautifulsoup4""": """beautifulsoup4""",
    """black""": """black~=23.1""",
    """codecarbon""": """codecarbon==1.2.0""",
    """cookiecutter""": """cookiecutter==1.7.3""",
    """dataclasses""": """dataclasses""",
    """datasets""": """datasets!=2.5.0""",
    """decord""": """decord==0.6.0""",
    """deepspeed""": """deepspeed>=0.9.3""",
    """diffusers""": """diffusers""",
    """dill""": """dill<0.3.5""",
    """evaluate""": """evaluate>=0.2.0""",
    """fairscale""": """fairscale>0.3""",
    """faiss-cpu""": """faiss-cpu""",
    """fastapi""": """fastapi""",
    """filelock""": """filelock""",
    """flax""": """flax>=0.4.1,<=0.7.0""",
    """ftfy""": """ftfy""",
    """fugashi""": """fugashi>=1.0""",
    """GitPython""": """GitPython<3.1.19""",
    """hf-doc-builder""": """hf-doc-builder>=0.3.0""",
    """huggingface-hub""": """huggingface-hub>=0.14.1,<1.0""",
    """importlib_metadata""": """importlib_metadata""",
    """ipadic""": """ipadic>=1.0.0,<2.0""",
    """isort""": """isort>=5.5.4""",
    """jax""": """jax>=0.2.8,!=0.3.2,<=0.4.13""",
    """jaxlib""": """jaxlib>=0.1.65,<=0.4.13""",
    """jieba""": """jieba""",
    """kenlm""": """kenlm""",
    """keras-nlp""": """keras-nlp>=0.3.1""",
    """librosa""": """librosa""",
    """nltk""": """nltk""",
    """natten""": """natten>=0.14.6""",
    """numpy""": """numpy>=1.17""",
    """onnxconverter-common""": """onnxconverter-common""",
    """onnxruntime-tools""": """onnxruntime-tools>=1.4.2""",
    """onnxruntime""": """onnxruntime>=1.4.0""",
    """opencv-python""": """opencv-python""",
    """optuna""": """optuna""",
    """optax""": """optax>=0.0.8,<=0.1.4""",
    """packaging""": """packaging>=20.0""",
    """parameterized""": """parameterized""",
    """phonemizer""": """phonemizer""",
    """protobuf""": """protobuf""",
    """psutil""": """psutil""",
    """pyyaml""": """pyyaml>=5.1""",
    """pydantic""": """pydantic<2""",
    """pytest""": """pytest>=7.2.0""",
    """pytest-timeout""": """pytest-timeout""",
    """pytest-xdist""": """pytest-xdist""",
    """python""": """python>=3.8.0""",
    """ray[tune]""": """ray[tune]""",
    """regex""": """regex!=2019.12.17""",
    """requests""": """requests""",
    """rhoknp""": """rhoknp>=1.1.0,<1.3.1""",
    """rjieba""": """rjieba""",
    """rouge-score""": """rouge-score!=0.0.7,!=0.0.8,!=0.1,!=0.1.1""",
    """ruff""": """ruff>=0.0.241,<=0.0.259""",
    """sacrebleu""": """sacrebleu>=1.4.12,<2.0.0""",
    """sacremoses""": """sacremoses""",
    """safetensors""": """safetensors>=0.3.1""",
    """sagemaker""": """sagemaker>=2.31.0""",
    """scikit-learn""": """scikit-learn""",
    """sentencepiece""": """sentencepiece>=0.1.91,!=0.1.92""",
    """sigopt""": """sigopt""",
    """starlette""": """starlette""",
    """sudachipy""": """sudachipy>=0.6.6""",
    """sudachidict_core""": """sudachidict_core>=20220729""",
    """tensorflow-cpu""": """tensorflow-cpu>=2.6,<2.14""",
    """tensorflow""": """tensorflow>=2.6,<2.14""",
    """tensorflow-text""": """tensorflow-text<2.14""",
    """tf2onnx""": """tf2onnx""",
    """timeout-decorator""": """timeout-decorator""",
    """timm""": """timm""",
    """tokenizers""": """tokenizers>=0.11.1,!=0.11.3,<0.14""",
    """torch""": """torch>=1.9,!=1.12.0""",
    """torchaudio""": """torchaudio""",
    """torchvision""": """torchvision""",
    """pyctcdecode""": """pyctcdecode>=0.4.0""",
    """tqdm""": """tqdm>=4.27""",
    """unidic""": """unidic>=1.0.2""",
    """unidic_lite""": """unidic_lite>=1.0.7""",
    """urllib3""": """urllib3<2.0.0""",
    """uvicorn""": """uvicorn""",
}





"""simple docstring"""






from typing import Any







class       snake_case__  :







			def __init__(			self			: Union[str, Any]			,  lowercase			: Any  ):





								'''simple docstring'''



								UpperCAmelCase			:   Dict      =				data
								UpperCAmelCase			:   Optional[Any]      =				None







			def __repr__(			self			: str  ):





								'''simple docstring'''



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







class       snake_case__  :







			def __init__(			self			: Optional[Any]  ):





								'''simple docstring'''



								UpperCAmelCase			:   Optional[Any]      =				None







			def __iter__(			self			: Dict  ):





								'''simple docstring'''



								UpperCAmelCase			:   str      =				self.head
								while node:
													yield node.data
													UpperCAmelCase			:   Tuple      =				node.next







			def __len__(			self			: Tuple  ):





								'''simple docstring'''



								return sum(1 for _ in self  )







			def __repr__(			self			: Any  ):





								'''simple docstring'''



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







			def __getitem__(			self			: List[str]			,  lowercase			: 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			: str			,  lowercase			: int			,  lowercase			: Any  ):





								'''simple docstring'''



								if not 0 <= index < len(self  ):
													raise ValueError("list index out of range."  )
								UpperCAmelCase			:   List[str]      =				self.head
								for _ in range(lowercase  ):
													UpperCAmelCase			:   List[Any]      =				current.next
								UpperCAmelCase			:   List[str]      =				data







			def 			__lowerCAmelCase				(			self			: Optional[Any]			,  lowercase			: Any  ):





								'''simple docstring'''



								self.insert_nth(len(self  )			,  lowercase  )







			def 			__lowerCAmelCase				(			self			: List[str]			,  lowercase			: Any  ):





								'''simple docstring'''



								self.insert_nth(0			,  lowercase  )







			def 			__lowerCAmelCase				(			self			: List[str]			,  lowercase			: int			,  lowercase			: Any  ):





								'''simple docstring'''



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







			def 			__lowerCAmelCase				(			self			: Dict  ):  # print every node data





								'''simple docstring'''



								print(self  )







			def 			__lowerCAmelCase				(			self			: Optional[Any]  ):





								'''simple docstring'''



								return self.delete_nth(0  )







			def 			__lowerCAmelCase				(			self			: str  ):  # delete from tail





								'''simple docstring'''



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







			def 			__lowerCAmelCase				(			self			: Optional[Any]			,  lowercase			: int = 0  ):





								'''simple docstring'''



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







			def 			__lowerCAmelCase				(			self			: List[Any]  ):





								'''simple docstring'''



								return self.head is None







			def 			__lowerCAmelCase				(			self			: int  ):





								'''simple docstring'''



								UpperCAmelCase			:   List[Any]      =				None
								UpperCAmelCase			:   str      =				self.head

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



def   lowercase_	(    ):




					'''simple docstring'''






					UpperCAmelCase			:   Optional[int]      =				LinkedList()
					assert linked_list.is_empty() is True
					assert str(_lowercase	) == ""

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

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

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



def   lowercase_	(    ):




					'''simple docstring'''






					UpperCAmelCase			:   Optional[Any]      =				[
					    -9,
					    1_00,
					    Node(77_34_51_12	),
					    "dlrow olleH",
					    7,
					    55_55,
					    0,
					    -1_9_2.5_5_5_5_5,
					    "Hello, world!",
					    7_7.9,
					    Node(10	),
					    None,
					    None,
					    1_2.2_0,
					]
					UpperCAmelCase			:   Optional[Any]      =				LinkedList()

					for i in test_input:
										linked_list.insert_tail(_lowercase	)

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

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

					# Delete the tail
					UpperCAmelCase			:   Any      =				linked_list.delete_tail()
					assert result == 1_2.2
					assert (
					    str(_lowercase	) == "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
					UpperCAmelCase			:   Union[str, Any]      =				linked_list.delete_nth(10	)
					assert result is None
					assert (
					    str(_lowercase	) == "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(_lowercase	)
					    == "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(_lowercase	)
					assert (
					    str(_lowercase	)
					    == "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(_lowercase	)
					    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
					    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
					)



def   lowercase_	(    ):




					'''simple docstring'''






					from doctest import testmod

					testmod()

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


if __name__ == "__main__":
	main()


