

from typing import Any


class       SCREAMING_SNAKE_CASE__					:





    def __init__(      self						,   a):
         lowercase__    :   Union[str, Any]      =       data
         lowercase__    :   List[str]      =       None





    def __repr__(      self):
         return f"""Node({self.data})"""



class       SCREAMING_SNAKE_CASE__					:





    def __init__(      self):
         lowercase__    :   Optional[int]      =       None





    def __iter__(      self):
         lowercase__    :   List[str]      =       self.head
         while node:
              yield node.data
              lowercase__    :   List[str]      =       node.next





    def __len__(      self):
         return sum(1 for _ in self)





    def __repr__(      self):
         return "->".join([str(_UpperCamelCase) for item in self])





    def __getitem__(      self						,   a):
         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						,   a						,   a):
         if not 0 <= index < len(self):
              raise ValueError('list index out of range.')
         lowercase__    :   Tuple      =       self.head
         for _ in range(_UpperCamelCase):
              lowercase__    :   Optional[Any]      =       current.next
         lowercase__    :   Optional[int]      =       data





    def       snake_case_				(      self						,   a):
         self.insert_nth(len(self)						,   _UpperCamelCase)





    def       snake_case_				(      self						,   a):
         self.insert_nth(0						,   _UpperCamelCase)





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





    def       snake_case_				(      self):  # print every node data
         print(self)





    def       snake_case_				(      self):
         return self.delete_nth(0)





    def       snake_case_				(      self):  # delete from tail
         return self.delete_nth(len(self) - 1)





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





    def       snake_case_				(      self):
         return self.head is None





    def       snake_case_				(      self):
         lowercase__    :   Any      =       None
         lowercase__    :   List[Any]      =       self.head

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



def 	snake_case__			(    ):



     '''simple docstring'''





     lowercase__    :   Optional[int]      =       LinkedList()
     assert linked_list.is_empty() is True
     assert str(SCREAMING_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(SCREAMING_SNAKE_CASE_			) == i
          linked_list.insert_nth(SCREAMING_SNAKE_CASE_	,     i + 1			)
     assert str(SCREAMING_SNAKE_CASE_			) == "->".join(str(SCREAMING_SNAKE_CASE_			) for i in range(1	,     11			)			)

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

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

def 	snake_case__			(    ):



     '''simple docstring'''





     lowercase__    :   str      =       [
         -9,
         100,
         Node(77_345_112			),
         'dlrow olleH',
         7,
         5_555,
         0,
         -192.5_5555,
         'Hello, world!',
         77.9,
         Node(10			),
         None,
         None,
         12.20,
     ]
     lowercase__    :   Optional[Any]      =       LinkedList()

     for i in test_input:
          linked_list.insert_tail(SCREAMING_SNAKE_CASE_			)

     # Check if it's empty or not
     assert linked_list.is_empty() is False
     assert (
         str(SCREAMING_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
     lowercase__    :   Optional[int]      =       linked_list.delete_head()
     assert result == -9
     assert (
         str(SCREAMING_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
     lowercase__    :   Dict      =       linked_list.delete_tail()
     assert result == 12.2
     assert (
         str(SCREAMING_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
     lowercase__    :   Optional[int]      =       linked_list.delete_nth(10			)
     assert result is None
     assert (
         str(SCREAMING_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(SCREAMING_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(SCREAMING_SNAKE_CASE_			)
     assert (
         str(SCREAMING_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(SCREAMING_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 	snake_case__			(    ):



     '''simple docstring'''





     from doctest import testmod

     testmod()

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


if __name__ == "__main__":
       main()








from __future__ import annotations



def _a				(	lowerCamelCase:   list[int | str] )	->						None:







      '''simple docstring'''






      create_state_space_tree(lowerCamelCase					,				[]					,				0					,				[0 for i in range(len(lowerCamelCase ) )] )



def _a				(	lowerCamelCase:   list[int | str]					,				lowerCamelCase:   list[int | str]					,				lowerCamelCase:   int					,				lowerCamelCase:   list[int]					,				)	->						None:







      '''simple docstring'''






      if index == len(lowerCamelCase ):
            print(lowerCamelCase )
            return

      for i in range(len(lowerCamelCase ) ):
            if not index_used[i]:
                  current_sequence.append(sequence[i] )
                  __A          =				True
                  create_state_space_tree(lowerCamelCase					,				lowerCamelCase					,				index + 1					,				lowerCamelCase )
                  current_sequence.pop()
                  __A          =				False
snake_case__					:							list[int | str]													=     [3, 1, 2, 4]
generate_all_permutations(sequence)

snake_case__					:							list[int | str]													=     ["A", "B", "C"]







generate_all_permutations(sequence_a)





