"""simple docstring"""






from typing import Any


class     UpperCAmelCase						:



    """simple docstring"""

    def __init__(   self    ,			_UpperCAmelCase							):
       lowercase__:   str					=      data
       lowercase__:   Optional[Any]					=      None






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



class     UpperCAmelCase						:



    """simple docstring"""

    def __init__(   self							):
       lowercase__:   List[str]					=      None






    def __iter__(   self							):
       lowercase__:   str					=      self.head
       while node:
          yield node.data
          lowercase__:   Any					=      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    ,			_UpperCAmelCase							):
       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							):
       if not 0 <= index < len(self							):
          raise ValueError('''list index out of range.'''							)
       lowercase__:   Optional[Any]					=      self.head
       for _ in range(_UpperCAmelCase							):
          lowercase__:   Tuple					=      current.next
       lowercase__:   List[Any]					=      data






    def _snake_case			(   self    ,			_UpperCAmelCase							):
       self.insert_nth(len(self							)    ,			_UpperCAmelCase							)






    def _snake_case			(   self    ,			_UpperCAmelCase							):
       self.insert_nth(0    ,			_UpperCAmelCase							)






    def _snake_case			(   self    ,			_UpperCAmelCase    ,			_UpperCAmelCase							):
       if not 0 <= index <= len(self							):
          raise IndexError('''list index out of range'''							)
       lowercase__:   Any					=      Node(_UpperCAmelCase							)
       if self.head is None:
          lowercase__:   Dict					=      new_node
       elif index == 0:
          lowercase__:   int					=      self.head  # link new_node to head
          lowercase__:   Union[str, Any]					=      new_node
       else:
          lowercase__:   str					=      self.head
          for _ in range(index - 1							):
             lowercase__:   Union[str, Any]					=      temp.next
          lowercase__:   Optional[int]					=      temp.next
          lowercase__:   str					=      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    ,			_UpperCAmelCase = 0							):
       if not 0 <= index <= len(self							) - 1:  # test if index is valid
          raise IndexError('''List index out of range.'''							)
       lowercase__:   int					=      self.head  # default first node
       if index == 0:
          lowercase__:   Optional[int]					=      self.head.next
       else:
          lowercase__:   Optional[Any]					=      self.head
          for _ in range(index - 1							):
             lowercase__:   Optional[int]					=      temp.next
          lowercase__:   str					=      temp.next
          lowercase__:   int					=      temp.next.next
       return delete_node.data






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






    def _snake_case			(   self							):
       lowercase__:   Optional[Any]					=      None
       lowercase__:   str					=      self.head

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



def SCREAMING_SNAKE_CASE__			(   )  ->  None:
   lowercase__:   List[Any]					=      LinkedList()
   assert linked_list.is_empty() is True
   assert str(__UpperCAmelCase ) == ""

   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(1_0 ):
      assert len(__UpperCAmelCase ) == i
      linked_list.insert_nth(__UpperCAmelCase       ,    i + 1 )
   assert str(__UpperCAmelCase ) == "->".join(str(__UpperCAmelCase ) for i in range(1       ,    1_1 ) )

   linked_list.insert_head(0 )
   linked_list.insert_tail(1_1 )
   assert str(__UpperCAmelCase ) == "->".join(str(__UpperCAmelCase ) for i in range(0       ,    1_2 ) )

   assert linked_list.delete_head() == 0
   assert linked_list.delete_nth(9 ) == 1_0
   assert linked_list.delete_tail() == 1_1
   assert len(__UpperCAmelCase ) == 9
   assert str(__UpperCAmelCase ) == "->".join(str(__UpperCAmelCase ) for i in range(1       ,    1_0 ) )

   assert all(linked_list[i] == i + 1 for i in range(0       ,    9 ) ) is True

   for i in range(0       ,    9 ):
      lowercase__:   List[Any]					=      -i
   assert all(linked_list[i] == -i for i in range(0       ,    9 ) ) is True

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



def SCREAMING_SNAKE_CASE__			(   )  ->  None:
   lowercase__:   List[str]					=      [
       -9,
       1_0_0,
       Node(7_7_3_4_5_1_1_2 ),
       '''dlrow olleH''',
       7,
       5_5_5_5,
       0,
       -1_9_2.5_5_5_5_5,
       '''Hello, world!''',
       7_7.9,
       Node(1_0 ),
       None,
       None,
       1_2.2_0,
   ]
   lowercase__:   Dict					=      LinkedList()

   for i in test_input:
      linked_list.insert_tail(__UpperCAmelCase )

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

   # Delete the tail
   lowercase__:   int					=      linked_list.delete_tail()
   assert result == 1_2.2
   assert (
       str(__UpperCAmelCase ) == "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__:   Any					=      linked_list.delete_nth(1_0 )
   assert result is None
   assert (
       str(__UpperCAmelCase ) == "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(__UpperCAmelCase )
       == "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(__UpperCAmelCase )
   assert (
       str(__UpperCAmelCase )
       == "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(__UpperCAmelCase )
       == "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__			(   )  ->  Union[str, Any]:
   from doctest import testmod

   testmod()

   lowercase__:   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(__UpperCAmelCase )
   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(__UpperCAmelCase )
   print(F"""length of linked_list is : {len(__UpperCAmelCase )}""" )


if __name__ == "__main__":
       main()

"""simple docstring"""






def SCREAMING_SNAKE_CASE__			(   __UpperCAmelCase=2_8_1_2_3 )  ->  Any:
   lowercase__:   Optional[Any]					=      [1] * (limit + 1)

   for i in range(2       ,    int(limit**0.5 ) + 1 ):
      sum_divs[i * i] += i
      for k in range(i + 1       ,    limit // i + 1 ):
         sum_divs[k * i] += k + i

   lowercase__:   Union[str, Any]					=      set()
   lowercase__:   Optional[Any]					=      0

   for n in range(1       ,    limit + 1 ):
      if sum_divs[n] > n:
         abundants.add(__UpperCAmelCase )

      if not any((n - a in abundants) for a in abundants ):
         res += n

   return res


if __name__ == "__main__":
       print(solution())
