def 			__SCREAMING_SNAKE_CASE						(      __UpperCamelCase					: str=2_81_23			)							->      List[str]:







  """simple docstring"""





  SCREAMING_SNAKE_CASE__    							=   [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

  SCREAMING_SNAKE_CASE__    							=   set()
  SCREAMING_SNAKE_CASE__    							=   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())

from collections.abc import Iterator, MutableMapping
from dataclasses import dataclass
from typing import Generic, TypeVar

__lowerCamelCase    :				List[str]							     =	TypeVar('''KEY''')
__lowerCamelCase    :				int							     =	TypeVar('''VAL''')







@dataclass(frozen=lowerCamelCase_     ,	slots=lowerCamelCase_	)
class __snake_case       (		Generic[KEY, VAL]	):
   lowerCAmelCase_														=							42
   lowerCAmelCase_														=							42







class __snake_case       (		_Item	):




   def __init__(					self    :       List[Any]   ):



     """simple docstring"""






     super().__init__(_lowercase ,			_lowercase   )




   def __bool__(					self    :       List[str]   ):



     """simple docstring"""






     return False





__lowerCamelCase    :				str							     =	_DeletedItem()







class __snake_case       (		MutableMapping[KEY, VAL]	):




   def __init__(					self    :       Optional[int] ,			_lowercase    :       int = 8 ,			_lowercase    :       float = 0.75   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   initial_block_size
     SCREAMING_SNAKE_CASE__    							=   [None] * initial_block_size
     assert 0.0 < capacity_factor < 1.0
     SCREAMING_SNAKE_CASE__    							=   capacity_factor
     SCREAMING_SNAKE_CASE__    							=   0




   def 			__a		(					self    :       Union[str, Any] ,			_lowercase    :       KEY   ):



     """simple docstring"""






     return hash(_lowercase   ) % len(self._buckets   )




   def 			__a		(					self    :       List[str] ,			_lowercase    :       int   ):



     """simple docstring"""






     return (ind + 1) % len(self._buckets   )




   def 			__a		(					self    :       Union[str, Any] ,			_lowercase    :       int ,			_lowercase    :       KEY ,			_lowercase    :       VAL   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self._buckets[ind]
     if not stored:
       SCREAMING_SNAKE_CASE__    							=   _Item(_lowercase ,			_lowercase   )
       self._len += 1
       return True
     elif stored.key == key:
       SCREAMING_SNAKE_CASE__    							=   _Item(_lowercase ,			_lowercase   )
       return True
     else:
       return False




   def 			__a		(					self    :       List[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   len(self._buckets   ) * self._capacity_factor
     return len(self   ) >= int(_lowercase   )




   def 			__a		(					self    :       Dict   ):



     """simple docstring"""






     if len(self._buckets   ) <= self._initial_block_size:
       return False
     SCREAMING_SNAKE_CASE__    							=   len(self._buckets   ) * self._capacity_factor / 2
     return len(self   ) < limit




   def 			__a		(					self    :       List[Any] ,			_lowercase    :       int   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self._buckets
     SCREAMING_SNAKE_CASE__    							=   [None] * new_size
     SCREAMING_SNAKE_CASE__    							=   0
     for item in old_buckets:
       if item:
         self._add_item(item.key ,			item.val   )




   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     self._resize(len(self._buckets   ) * 2   )




   def 			__a		(					self    :       Tuple   ):



     """simple docstring"""






     self._resize(len(self._buckets   ) // 2   )




   def 			__a		(					self    :       List[str] ,			_lowercase    :       KEY   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   self._get_bucket_index(_lowercase   )
     for _ in range(len(self._buckets   )   ):
       yield ind
       SCREAMING_SNAKE_CASE__    							=   self._get_next_ind(_lowercase   )




   def 			__a		(					self    :       List[str] ,			_lowercase    :       KEY ,			_lowercase    :       VAL   ):



     """simple docstring"""






     for ind in self._iterate_buckets(_lowercase   ):
       if self._try_set(_lowercase ,			_lowercase ,			_lowercase   ):
         break




   def __setitem__(					self    :       List[str] ,			_lowercase    :       KEY ,			_lowercase    :       VAL   ):



     """simple docstring"""






     if self._is_full():
       self._size_up()

     self._add_item(_lowercase ,			_lowercase   )




   def __delitem__(					self    :       Tuple ,			_lowercase    :       KEY   ):



     """simple docstring"""






     for ind in self._iterate_buckets(_lowercase   ):
       SCREAMING_SNAKE_CASE__    							=   self._buckets[ind]
       if item is None:
         raise KeyError(_lowercase   )
       if item is _deleted:
         continue
       if item.key == key:
         SCREAMING_SNAKE_CASE__    							=   _deleted
         self._len -= 1
         break
     if self._is_sparse():
       self._size_down()




   def __getitem__(					self    :       Tuple ,			_lowercase    :       KEY   ):



     """simple docstring"""






     for ind in self._iterate_buckets(_lowercase   ):
       SCREAMING_SNAKE_CASE__    							=   self._buckets[ind]
       if item is None:
         break
       if item is _deleted:
         continue
       if item.key == key:
         return item.val
     raise KeyError(_lowercase   )




   def __len__(					self    :       List[Any]   ):



     """simple docstring"""






     return self._len




   def __iter__(					self    :       List[str]   ):



     """simple docstring"""






     yield from (item.key for item in self._buckets if item)




   def __repr__(					self    :       Optional[Any]   ):



     """simple docstring"""






     SCREAMING_SNAKE_CASE__    							=   """ ,""".join(
         f"""{item.key}: {item.val}""" for item in self._buckets if item   )
     return f"""HashMap({val_string})"""
