


"""simple docstring"""



from typing import Any







class _lowerCAmelCase				:







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

       '''simple docstring'''




       snake_case    :      Optional[int]      					=    data
       snake_case    :      str      					=    None







   def __repr__(	self						)	->		str:

       '''simple docstring'''




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







class _lowerCAmelCase				:







   def __init__(	self						)	->		int:

       '''simple docstring'''




       snake_case    :      Optional[Any]      					=    None







   def __iter__(	self						)	->		Any:

       '''simple docstring'''




       snake_case    :      Any      					=    self.head
       while node:
           yield node.data
           snake_case    :      int      					=    node.next







   def __len__(	self						)	->		int:

       '''simple docstring'''




       return sum(1 for _ in self						)







   def __repr__(	self						)	->		str:

       '''simple docstring'''




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







   def __getitem__(	self						,	UpperCamelCase__						)	->		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						,	UpperCamelCase__						,	UpperCamelCase__						)	->		None:

       '''simple docstring'''




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







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		None:

       '''simple docstring'''




       self.insert_nth(len(self						)						,	UpperCamelCase__						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						)	->		None:

       '''simple docstring'''




       self.insert_nth(0						,	UpperCamelCase__						)







   def  lowerCamelCase		(	self						,	UpperCamelCase__						,	UpperCamelCase__						)	->		None:

       '''simple docstring'''




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







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

       '''simple docstring'''




       print(self						)







   def  lowerCamelCase		(	self						)	->		Any:

       '''simple docstring'''




       return self.delete_nth(0						)







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

       '''simple docstring'''




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







   def  lowerCamelCase		(	self						,	UpperCamelCase__ = 0						)	->		Any:

       '''simple docstring'''




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







   def  lowerCamelCase		(	self						)	->		bool:

       '''simple docstring'''




       return self.head is None







   def  lowerCamelCase		(	self						)	->		None:

       '''simple docstring'''




       snake_case    :      str      					=    None
       snake_case    :      Optional[int]      					=    self.head

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







def   __lowerCAmelCase						(						)	->						None:


    """simple docstring"""





    snake_case    :      Dict      					=    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 ):
        snake_case    :      List[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   __lowerCAmelCase						(						)	->						None:


    """simple docstring"""





    snake_case    :      Any      					=    [
        -9,
        100,
        Node(7734_5112 ),
        "dlrow olleH",
        7,
        5555,
        0,
        -192.5_5555,
        "Hello, world!",
        77.9,
        Node(10 ),
        None,
        None,
        12.20,
    ]
    snake_case    :      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
    snake_case    :      Dict      					=    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
    snake_case    :      Optional[Any]      					=    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
    snake_case    :      List[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   __lowerCAmelCase						(						)	->						Union[str, Any]:


    """simple docstring"""





    from doctest import testmod

    testmod()

    snake_case    :      str      					=    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]}' )
    snake_case    :      Union[str, Any]      					=    input("Enter New Value: " ).strip()
    print("New list:" )
    print(lowercase )
    print(F'length of linked_list is : {len(lowercase )}' )


if __name__ == "__main__":
  main()









"""simple docstring"""



def   __lowerCAmelCase						(						lowercase  :  int )	->						bool:


    """simple docstring"""





    if p < 2:
        raise ValueError("p should not be less than 2!" )
    elif p == 2:
        return True

    snake_case    :      Dict      					=    4
    snake_case    :      str      					=    (1 << p) - 1
    for _ in range(p - 2 ):
        snake_case    :      Any      					=    ((s * s) - 2) % m
    return s == 0


if __name__ == "__main__":
  print(lucas_lehmer_test(7))
  print(lucas_lehmer_test(11))





