
"""simple docstring"""




from typing import Any



class 			lowerCAmelCase_		:


				"""simple docstring"""



				def __init__(self     , SCREAMING_SNAKE_CASE__					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     data
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     None



				def __repr__(self					)      ->	str:



											"""simple docstring"""




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






class 			lowerCAmelCase_		:


				"""simple docstring"""



				def __init__(self					)      ->	Dict:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     None



				def __iter__(self					)      ->	Any:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Dict     =     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					)      ->	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."""					)
											SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.head
											for _ in range(SCREAMING_SNAKE_CASE__					):
																		SCREAMING_SNAKE_CASE__		: Optional[Any]     =     current.next
											SCREAMING_SNAKE_CASE__		: Any     =     data



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	None:



											"""simple docstring"""




											self.insert_nth(len(self					)     , SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__					)      ->	None:



											"""simple docstring"""




											self.insert_nth(0     , SCREAMING_SNAKE_CASE__					)



				def 			__magic_name__					(self     , SCREAMING_SNAKE_CASE__     , SCREAMING_SNAKE_CASE__					)      ->	None:



											"""simple docstring"""




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



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



											"""simple docstring"""




											print(self					)



				def 			__magic_name__					(self					)      ->	Any:



											"""simple docstring"""




											return self.delete_nth(0					)



				def 			__magic_name__					(self					)      ->	Any:  # delete from tail



											"""simple docstring"""




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



				def 			__magic_name__					(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."""					)
											SCREAMING_SNAKE_CASE__		: str     =     self.head  # default first node
											if index == 0:
																		SCREAMING_SNAKE_CASE__		: Any     =     self.head.next
											else:
																		SCREAMING_SNAKE_CASE__		: Optional[int]     =     self.head
																		for _ in range(index - 1					):
																									SCREAMING_SNAKE_CASE__		: Tuple     =     temp.next
																		SCREAMING_SNAKE_CASE__		: Any     =     temp.next
																		SCREAMING_SNAKE_CASE__		: Optional[int]     =     temp.next.next
											return delete_node.data



				def 			__magic_name__					(self					)      ->	bool:



											"""simple docstring"""




											return self.head is None



				def 			__magic_name__					(self					)      ->	None:



											"""simple docstring"""




											SCREAMING_SNAKE_CASE__		: Tuple     =     None
											SCREAMING_SNAKE_CASE__		: Union[str, Any]     =     self.head

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






def lowercase_						(     ):
							SCREAMING_SNAKE_CASE__		: List[str]     =     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		):
														SCREAMING_SNAKE_CASE__		: 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 lowercase_						(     ):
							SCREAMING_SNAKE_CASE__		: Optional[int]     =     [
							    -9,
							    100,
							    Node(77_345_112		),
							    """dlrow olleH""",
							    7,
							    5_555,
							    0,
							    -192.55555,
							    """Hello, world!""",
							    77.9,
							    Node(10		),
							    None,
							    None,
							    12.20,
							]
							SCREAMING_SNAKE_CASE__		: Tuple     =     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
							SCREAMING_SNAKE_CASE__		: Dict     =     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
							SCREAMING_SNAKE_CASE__		: Union[str, 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
							SCREAMING_SNAKE_CASE__		: Tuple     =     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 lowercase_						(     ):
							from doctest import testmod

							testmod()

							SCREAMING_SNAKE_CASE__		: Tuple     =     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]}'''		)
							SCREAMING_SNAKE_CASE__		: Tuple     =     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"""




def lowercase_						(     _snake_case		):
							if divisor % 5 == 0 or divisor % 2 == 0:
														return 0
							SCREAMING_SNAKE_CASE__		: List[str]     =     1
							SCREAMING_SNAKE_CASE__		: List[Any]     =     1
							while repunit:
														SCREAMING_SNAKE_CASE__		: Dict     =     (10 * repunit + 1) % divisor
														repunit_index += 1
							return repunit_index

def lowercase_						(     _snake_case = 1_000_000		):
							SCREAMING_SNAKE_CASE__		: int     =     limit - 1
							if divisor % 2 == 0:
														divisor += 1
							while least_divisible_repunit(_snake_case		) <= limit:
														divisor += 2
							return divisor


if __name__ == "__main__":
					print(f"""{solution() = }""")




