


"""simple docstring"""





from typing import Any



class 						snake_case_:






     def __init__(		self     :    Any    , UpperCamelCase_     :    Any ):
           lowerCAmelCase    :		Optional[Any]				=      data
           lowerCAmelCase    :		Optional[int]				=      None






     def __repr__(		self     :    str ):
           return F'''Node({self.data})'''



class 						snake_case_:






     def __init__(		self     :    str ):
           lowerCAmelCase    :		Dict				=      None






     def __iter__(		self     :    int ):
           lowerCAmelCase    :		str				=      self.head
           while node:
                 yield node.data
                 lowerCAmelCase    :		Union[str, Any]				=      node.next






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






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






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






     def    lowerCamelCase__   (		self     :    Any    , UpperCamelCase_     :    Any ):
           self.insert_nth(len(self )    , __UpperCAmelCase )






     def    lowerCamelCase__   (		self     :    List[Any]    , UpperCamelCase_     :    Any ):
           self.insert_nth(0    , __UpperCAmelCase )






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






     def    lowerCamelCase__   (		self     :    int ):  # print every node data
           print(self )






     def    lowerCamelCase__   (		self     :    Optional[Any] ):
           return self.delete_nth(0 )






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






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






     def    lowerCamelCase__   (		self     :    int ):
           return self.head is None






     def    lowerCamelCase__   (		self     :    List[Any] ):
           lowerCAmelCase    :		str				=      None
           lowerCAmelCase    :		Tuple				=      self.head

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



def    _snake_case  (  ):
      lowerCAmelCase    :		Any				=      LinkedList()
      assert linked_list.is_empty() is True
      assert str(A_	) == ""

      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(A_	) == i
            linked_list.insert_nth(A_       ,      i + 1	)
      assert str(A_	) == "->".join(str(A_	) for i in range(1       ,      11	)	)

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

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


def    _snake_case  (  ):
      lowerCAmelCase    :		str				=      [
          -9,
          100,
          Node(77345112	),
          "dlrow olleH",
          7,
          5555,
          0,
          -192.55555,
          "Hello, world!",
          77.9,
          Node(10	),
          None,
          None,
          12.20,
      ]
      lowerCAmelCase    :		str				=      LinkedList()

      for i in test_input:
            linked_list.insert_tail(A_	)

      # Check if it's empty or not
      assert linked_list.is_empty() is False
      assert (
          str(A_	) == "-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    :		int				=      linked_list.delete_head()
      assert result == -9
      assert (
          str(A_	) == "100->Node(77345112)->dlrow olleH->7->5555->0->-192.55555->"
          "Hello, world!->77.9->Node(10)->None->None->12.2"
      )

      # Delete the tail
      lowerCAmelCase    :		int				=      linked_list.delete_tail()
      assert result == 12.2
      assert (
          str(A_	) == "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    :		Union[str, Any]				=      linked_list.delete_nth(10	)
      assert result is None
      assert (
          str(A_	) == "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(A_	)
          == "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(A_	)
      assert (
          str(A_	)
          == "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(A_	)
          == "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  (  ):
      from doctest import testmod

      testmod()

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


if __name__ == "__main__":
 main()






"""simple docstring"""







def      lowercase			(				A_       )->      str:
  '''simple docstring'''







  if isinstance(A_  ,   A_       ):
    raise TypeError("'float' object cannot be interpreted as an integer"       )
  if isinstance(A_  ,   A_       ):
    raise TypeError("'str' object cannot be interpreted as an integer"       )

  if num == 0:
    return "0b0"

  a						:		Optional[Any]      							=			False

  if num < 0:
    a						:		Tuple      							=			True
    a						:		str      							=			-num

  a						:		list[int]      							=			[]
  while num > 0:
    binary.insert(0  ,   num % 2       )
    num >>= 1

  if negative:
    return "-0b" + "".join(str(A_       ) for e in binary       )

  return "0b" + "".join(str(A_       ) for e in binary       )


if __name__ == "__main__":
 import doctest

 doctest.testmod()






