





"""simple docstring"""




def       _SCREAMING_SNAKE_CASE		(	_lowercase						:    Any					) ->Any:






	'''simple docstring'''






	a      :		List[str]	=				1
	a      :		List[Any]	=				2
	while i * i <= n:
		a      :		Any	=				0
		while n % i == 0:
			n //= i
			multiplicity += 1
		n_divisors *= multiplicity + 1
		i += 1
	if n > 1:
		n_divisors *= 2
	return n_divisors






def       _SCREAMING_SNAKE_CASE		(	) ->Optional[Any]:






	'''simple docstring'''






	a      :		Union[str, Any]	=				1
	a      :		str	=				1

	while True:
		i += 1
		t_num += i

		if count_divisors(_lowercase					) > 500:
			break

	return t_num


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










from __future__ import annotations

import sys
from collections import deque
from typing import Generic, TypeVar

lowerCamelCase	:							int				=TypeVar('''T''')





class 			__a  (    Generic[T]       ):
 _lowerCAmelCase       :       deque[T]  # Cache store of keys
 _lowerCAmelCase       :       set[T]  # References of the keys in cache
 _lowerCAmelCase       :       int        = 1_0  # Maximum capacity of cache







 def __init__(		self					:   List[str]							,   SCREAMING_SNAKE_CASE					:   int						):


      '''simple docstring'''






      UpperCamelCase__			:   Tuple       				=  deque()
      UpperCamelCase__			:   Optional[int]       				=  set()
      if not n:
           UpperCamelCase__			:   Tuple       				=  sys.maxsize
      elif n < 0:
           raise ValueError("n should be an integer greater than 0."						)
      else:
           UpperCamelCase__			:   Dict       				=  n







 def 					__lowercase					(		self					:   List[Any]							,   SCREAMING_SNAKE_CASE					:   T						):


      '''simple docstring'''






      if x not in self.key_reference:
           if len(self.dq_store						) == LRUCache._MAX_CAPACITY:
                UpperCamelCase__			:   int       				=  self.dq_store.pop()
                self.key_reference.remove(SCREAMING_SNAKE_CASE						)
      else:
           self.dq_store.remove(SCREAMING_SNAKE_CASE						)

      self.dq_store.appendleft(SCREAMING_SNAKE_CASE						)
      self.key_reference.add(SCREAMING_SNAKE_CASE						)







 def 					__lowercase					(		self					:   Dict						):


      '''simple docstring'''






      for k in self.dq_store:
           print(SCREAMING_SNAKE_CASE						)







 def __repr__(		self					:   Union[str, Any]						):


      '''simple docstring'''






      return F'LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store						)}'


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 lowerCamelCase	:							LRUCache[str | int]				=LRUCache(4)
 lru_cache.refer('''A''')
 lru_cache.refer(2)
 lru_cache.refer(3)
 lru_cache.refer('''A''')
 lru_cache.refer(4)
 lru_cache.refer(5)
 lru_cache.display()

 print(lru_cache)
 assert str(lru_cache) == "LRUCache(4) => [5, 4, 'A', 3]"