




from typing import Any



class       UpperCAmelCase__:

   '''simple docstring'''




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




         """simple docstring"""

         lowercase__     =  data
         lowercase__     =  None



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




         """simple docstring"""

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



class       UpperCAmelCase__:

   '''simple docstring'''




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




         """simple docstring"""

         lowercase__     =  None


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




         """simple docstring"""

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


   def __len__(						self  :			str)	->				int:




         """simple docstring"""

         return sum(1 for _ in self)


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




         """simple docstring"""

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


   def __getitem__(						self  :			Union[str, Any]			,				lowerCAmelCase  :			int)	->				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[int]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Any)	->				None:




         """simple docstring"""

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


   def 			UpperCAmelCase		(						self  :			Union[str, Any]			,				lowerCAmelCase  :			Any)	->				None:




         """simple docstring"""

         self.insert_nth(len(self)			,				UpperCamelCase_)


   def 			UpperCAmelCase		(						self  :			Optional[Any]			,				lowerCAmelCase  :			Any)	->				None:




         """simple docstring"""

         self.insert_nth(0			,				UpperCamelCase_)


   def 			UpperCAmelCase		(						self  :			Optional[int]			,				lowerCAmelCase  :			int			,				lowerCAmelCase  :			Any)	->				None:




         """simple docstring"""

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


   def 			UpperCAmelCase		(						self  :			Optional[int])	->				None:  # print every node data




         """simple docstring"""

         print(self)


   def 			UpperCAmelCase		(						self  :			int)	->				Any:




         """simple docstring"""

         return self.delete_nth(0)


   def 			UpperCAmelCase		(						self  :			Union[str, Any])	->				Any:  # delete from tail




         """simple docstring"""

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


   def 			UpperCAmelCase		(						self  :			Tuple			,				lowerCAmelCase  :			int = 0)	->				Any:




         """simple docstring"""

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


   def 			UpperCAmelCase		(						self  :			Tuple)	->				bool:




         """simple docstring"""

         return self.head is None



   def 			UpperCAmelCase		(						self  :			Optional[int])	->				None:




         """simple docstring"""

         lowercase__     =  None
         lowercase__     =  self.head

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

def   _lowerCAmelCase   (						):
      lowercase__     =  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	):
            lowercase__     =  -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   (						):
      lowercase__     =  [
          -9,
          100,
          Node(77_345_112	),
          'dlrow olleH',
          7,
          5_555,
          0,
          -192.55_555,
          'Hello, world!',
          77.9,
          Node(10	),
          None,
          None,
          12.20,
      ]
      lowercase__     =  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
      lowercase__     =  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
      lowercase__     =  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
      lowercase__     =  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   (						):
      from doctest import testmod

      testmod()

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


if __name__ == "__main__":
       main()





from maths.is_square_free import is_square_free
from maths.prime_factors import prime_factors

def   _lowerCAmelCase   (						A__	):
      lowercase__     =  prime_factors(A__	)
      if is_square_free(A__	):
            return -1 if len(A__	) % 2 else 1
      return 0


if __name__ == "__main__":
       import doctest

       doctest.testmod()
