


"""simple docstring"""






from typing import Any






class      A:

		"""simple docstring"""





		def __init__( self					,				SCREAMING_SNAKE_CASE__   )      ->	List[str]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	data
					_UpperCamelCase					:Dict					     =	None





		def __repr__( self   )      ->	str:

					"""simple docstring"""



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






class      A:

		"""simple docstring"""





		def __init__( self   )      ->	Dict:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	None
		def __iter__( self   )      ->	Any:

					"""simple docstring"""



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

					"""simple docstring"""



					return sum(1 for _ in self   )
		def __repr__( self   )      ->	str:

					"""simple docstring"""



					return "->".join([str(SCREAMING_SNAKE_CASE__   ) for item in self]   )
		def __getitem__( self					,				SCREAMING_SNAKE_CASE__   )      ->	Any:

					"""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					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	None:

					"""simple docstring"""



					if not 0 <= index < len(self   ):
								raise ValueError('''list index out of range.'''   )
					_UpperCamelCase					:List[str]					     =	self.head
					for _ in range(SCREAMING_SNAKE_CASE__   ):
								_UpperCamelCase					:Tuple					     =	current.next
					_UpperCamelCase					:Union[str, Any]					     =	data
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	None:

					"""simple docstring"""



					self.insert_nth(len(self   )					,				SCREAMING_SNAKE_CASE__   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__   )      ->	None:

					"""simple docstring"""



					self.insert_nth(0					,				SCREAMING_SNAKE_CASE__   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__					,				SCREAMING_SNAKE_CASE__   )      ->	None:

					"""simple docstring"""



					if not 0 <= index <= len(self   ):
								raise IndexError('''list index out of range'''   )
					_UpperCamelCase					:Optional[int]					     =	Node(SCREAMING_SNAKE_CASE__   )
					if self.head is None:
								_UpperCamelCase					:Optional[Any]					     =	new_node
					elif index == 0:
								_UpperCamelCase					:Any					     =	self.head  # link new_node to head
								_UpperCamelCase					:Union[str, Any]					     =	new_node
					else:
								_UpperCamelCase					:str					     =	self.head
								for _ in range(index - 1   ):
											_UpperCamelCase					:Optional[Any]					     =	temp.next
								_UpperCamelCase					:Optional[int]					     =	temp.next
								_UpperCamelCase					:Optional[Any]					     =	new_node
		def   _UpperCamelCase( self   )      ->	None:  # print every node data

					"""simple docstring"""



					print(self   )
		def   _UpperCamelCase( self   )      ->	Any:

					"""simple docstring"""



					return self.delete_nth(0   )
		def   _UpperCamelCase( self   )      ->	Any:  # delete from tail

					"""simple docstring"""



					return self.delete_nth(len(self   ) - 1   )
		def   _UpperCamelCase( self					,				SCREAMING_SNAKE_CASE__ = 0   )      ->	Any:

					"""simple docstring"""



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

					"""simple docstring"""



					return self.head is None





		def   _UpperCamelCase( self   )      ->	None:

					"""simple docstring"""



					_UpperCamelCase					:List[Any]					     =	None
					_UpperCamelCase					:Dict					     =	self.head

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





def 				A_       ( )					->  None:
			_UpperCamelCase					:List[Any]					     =	LinkedList()
			assert linked_list.is_empty() is True
			assert str(snake_case__		) == ""

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

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

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





def 				A_       ( )					->  None:
			_UpperCamelCase					:Optional[int]					     =	[
			    -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,
			]
			_UpperCamelCase					:Optional[int]					     =	LinkedList()

			for i in test_input:
						linked_list.insert_tail(snake_case__		)

			# Check if it's empty or not
			assert linked_list.is_empty() is False
			assert (
			    str(snake_case__		) == "-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					:Optional[int]					     =	linked_list.delete_head()
			assert result == -9
			assert (
			    str(snake_case__		) == "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 == 12.2
			assert (
			    str(snake_case__		) == "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(snake_case__		) == "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(snake_case__		)
			    == "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(snake_case__		)
			assert (
			    str(snake_case__		)
			    == "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(snake_case__		)
			    == "None->None->Node(10)->77.9->Hello, world!->-192.55555->0->5555->"
			    "7->dlrow olleH->Node(77345112)->100->Node(Hello again, world!)"
			)





def 				A_       ( )					->  Optional[Any]:
			from doctest import testmod

			testmod()

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


if __name__ == "__main__":
					main()





"""simple docstring"""






import unittest

from transformers.testing_utils import CaptureStdout
from transformers.tools.python_interpreter import evaluate





def 				A_       ( snake_case__		)					->  Union[str, Any]:
			return x + 2






class      A(  unittest.TestCase		):

		"""simple docstring"""





		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	'''x = 3'''
					_UpperCamelCase					:List[str]					     =	{}
					_UpperCamelCase					:int					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3}   )

					_UpperCamelCase					:Tuple					     =	'''x = y'''
					_UpperCamelCase					:Optional[int]					     =	{'''y''': 5}
					_UpperCamelCase					:Optional[Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 5, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''y = add_two(x)'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )

					# Won't work without the tool
					with CaptureStdout() as out:
								_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result is None
					assert "tried to execute add_two" in out.out
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:Any					     =	'''x = 3'''
					_UpperCamelCase					:int					     =	{}
					_UpperCamelCase					:List[Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3}   )
		def   _UpperCamelCase( self   )      ->	List[Any]:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''test_dict = {\'x\': x, \'y\': add_two(x)}'''
					_UpperCamelCase					:str					     =	{'''x''': 3}
					_UpperCamelCase					:Dict					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:int					     =	'''x = 3\ny = 5'''
					_UpperCamelCase					:int					     =	{}
					_UpperCamelCase					:Optional[int]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	Optional[int]:

					"""simple docstring"""



					_UpperCamelCase					:Union[str, Any]					     =	'''text = f\'This is x: {x}.\''''
					_UpperCamelCase					:List[str]					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == "This is x: 3."
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''text''': '''This is x: 3.'''}   )
		def   _UpperCamelCase( self   )      ->	Union[str, Any]:

					"""simple docstring"""



					_UpperCamelCase					:Optional[Any]					     =	'''if x <= 3:\n    y = 2\nelse:\n    y = 5'''
					_UpperCamelCase					:Dict					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 2
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 2}   )

					_UpperCamelCase					:Union[str, Any]					     =	{'''x''': 8}
					_UpperCamelCase					:Optional[int]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					# evaluate returns the value of the last assignment.
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 8, '''y''': 5}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:List[str]					     =	'''test_list = [x, add_two(x)]'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:str					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					self.assertListEqual(SCREAMING_SNAKE_CASE__					,				[3, 5]   )
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_list''': [3, 5]}   )
		def   _UpperCamelCase( self   )      ->	Dict:

					"""simple docstring"""



					_UpperCamelCase					:List[Any]					     =	'''y = x'''
					_UpperCamelCase					:List[str]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 3
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''y''': 3}   )
		def   _UpperCamelCase( self   )      ->	Tuple:

					"""simple docstring"""



					_UpperCamelCase					:Tuple					     =	'''test_list = [x, add_two(x)]\ntest_list[1]'''
					_UpperCamelCase					:Optional[Any]					     =	{'''x''': 3}
					_UpperCamelCase					:Any					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_list''': [3, 5]}   )

					_UpperCamelCase					:str					     =	'''test_dict = {\'x\': x, \'y\': add_two(x)}\ntest_dict[\'y\']'''
					_UpperCamelCase					:Optional[int]					     =	{'''x''': 3}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''add_two''': add_two}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 5
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 3, '''test_dict''': {'''x''': 3, '''y''': 5}}   )





		def   _UpperCamelCase( self   )      ->	int:

					"""simple docstring"""



					_UpperCamelCase					:str					     =	'''x = 0\nfor i in range(3):\n    x = i'''
					_UpperCamelCase					:Tuple					     =	{}
					_UpperCamelCase					:Union[str, Any]					     =	evaluate(SCREAMING_SNAKE_CASE__					,				{'''range''': range}					,				state=SCREAMING_SNAKE_CASE__   )
					assert result == 2
					self.assertDictEqual(SCREAMING_SNAKE_CASE__					,				{'''x''': 2, '''i''': 2}   )

