




from typing import Any







class   A:



 '''simple docstring'''


 def __init__(    self :  Optional[Any]						,							A_ :  Union[str, Any]  )       ->     Dict:

       """simple docstring"""






       lowerCamelCase_							=   data
       lowerCamelCase_							=   None





 def __repr__(    self :  List[str]  )       ->     str:

       """simple docstring"""






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







class   A:



 '''simple docstring'''


 def __init__(    self :  Dict  )       ->     Tuple:

       """simple docstring"""






       lowerCamelCase_							=   None

 def __iter__(    self :  List[Any]  )       ->     Any:

       """simple docstring"""






       lowerCamelCase_							=   self.head
       while node:
             yield node.data
             lowerCamelCase_							=   node.next

 def __len__(    self :  List[str]  )       ->     int:

       """simple docstring"""






       return sum(1 for _ in self  )

 def __repr__(    self :  Optional[int]  )       ->     str:

       """simple docstring"""






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

 def __getitem__(    self :  Optional[int]						,							A_ :  Dict  )       ->     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 :  Optional[Any]						,							A_ :  Dict						,							A_ :  Tuple  )       ->     None:

       """simple docstring"""






       if not 0 <= index < len(self  ):
             raise ValueError('list index out of range.'  )
       lowerCamelCase_							=   self.head
       for _ in range(_SCREAMING_SNAKE_CASE  ):
             lowerCamelCase_							=   current.next
       lowerCamelCase_							=   data

 def     a__			(    self :  Dict						,							A_ :  Any  )       ->     None:

       """simple docstring"""






       self.insert_nth(len(self  )						,							_SCREAMING_SNAKE_CASE  )

 def     a__			(    self :  Optional[Any]						,							A_ :  int  )       ->     None:

       """simple docstring"""






       self.insert_nth(0						,							_SCREAMING_SNAKE_CASE  )

 def     a__			(    self :  Any						,							A_ :  Dict						,							A_ :  Union[str, Any]  )       ->     None:

       """simple docstring"""






       if not 0 <= index <= len(self  ):
             raise IndexError('list index out of range'  )
       lowerCamelCase_							=   Node(_SCREAMING_SNAKE_CASE  )
       if self.head is None:
             lowerCamelCase_							=   new_node
       elif index == 0:
             lowerCamelCase_							=   self.head  # link new_node to head
             lowerCamelCase_							=   new_node
       else:
             lowerCamelCase_							=   self.head
             for _ in range(index - 1  ):
                   lowerCamelCase_							=   temp.next
             lowerCamelCase_							=   temp.next
             lowerCamelCase_							=   new_node

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

       """simple docstring"""






       print(self  )

 def     a__			(    self :  Union[str, Any]  )       ->     Any:

       """simple docstring"""






       return self.delete_nth(0  )

 def     a__			(    self :  Optional[int]  )       ->     Any:  # delete from tail

       """simple docstring"""






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

 def     a__			(    self :  str						,							A_ :  List[str] = 0  )       ->     Any:

       """simple docstring"""






       if not 0 <= index <= len(self  ) - 1:  # test if index is valid
             raise IndexError('List index out of range.'  )
       lowerCamelCase_							=   self.head  # default first node
       if index == 0:
             lowerCamelCase_							=   self.head.next
       else:
             lowerCamelCase_							=   self.head
             for _ in range(index - 1  ):
                   lowerCamelCase_							=   temp.next
             lowerCamelCase_							=   temp.next
             lowerCamelCase_							=   temp.next.next
       return delete_node.data

 def     a__			(    self :  int  )       ->     bool:

       """simple docstring"""






       return self.head is None





 def     a__			(    self :  Any  )       ->     None:

       """simple docstring"""






       lowerCamelCase_							=   None
       lowerCamelCase_							=   self.head

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

def       _SCREAMING_SNAKE_CASE      (							):


      '''simple docstring'''



      lowerCamelCase_							=   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					):
            lowerCamelCase_							=   -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       _SCREAMING_SNAKE_CASE      (							):


      '''simple docstring'''



      lowerCamelCase_							=   [
          -9,
          1_00,
          Node(77_34_51_12					),
          """dlrow olleH""",
          7,
          55_55,
          0,
          -192.5_5555,
          """Hello, world!""",
          77.9,
          Node(10					),
          None,
          None,
          12.20,
      ]
      lowerCamelCase_							=   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
      lowerCamelCase_							=   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
      lowerCamelCase_							=   linked_list.delete_tail()
      assert result == 12.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
      lowerCamelCase_							=   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       _SCREAMING_SNAKE_CASE      (							):


      '''simple docstring'''



      from doctest import testmod

      testmod()

      lowerCamelCase_							=   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]}"""					)
      lowerCamelCase_							=   input('Enter New Value: '					).strip()
      print('New list:'					)
      print(lowercase					)
      print(f"""length of linked_list is : {len(lowercase					)}"""					)


if __name__ == "__main__":
 main()









def       _SCREAMING_SNAKE_CASE      (							lowercase     :	str     ,							lowercase     :	int					):


      '''simple docstring'''



      return [sentence[i : i + ngram_size] for i in range(len(lowercase					) - ngram_size + 1					)]


if __name__ == "__main__":
 from doctest import testmod

 testmod()



