






A__	:			List[Any]			   = [
    (10_00, '''M'''),
    (9_00, '''CM'''),
    (5_00, '''D'''),
    (4_00, '''CD'''),
    (1_00, '''C'''),
    (90, '''XC'''),
    (50, '''L'''),
    (40, '''XL'''),
    (10, '''X'''),
    (9, '''IX'''),
    (5, '''V'''),
    (4, '''IV'''),
    (1, '''I'''),
]






def   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			{"I": 1, "V": 5, "X": 10, "L": 50, "C": 100, "D": 500, "M": 1000}
				lowercase__    =			0
				lowercase__    =			0
				while place < len(__lowerCAmelCase				):
								if (place + 1 < len(__lowerCAmelCase				)) and (vals[roman[place]] < vals[roman[place + 1]]):
												total += vals[roman[place + 1]] - vals[roman[place]]
												place += 2
								else:
												total += vals[roman[place]]
												place += 1
				return total






def   a			(						lowerCamelCase_				):






				'''simple docstring'''
				lowercase__    =			[]
				for arabic, roman in ROMAN:
								(lowercase__)    =			divmod(__lowerCAmelCase		,   __lowerCAmelCase				)
								result.append(roman * factor				)
								if number == 0:
												break
				return "".join(__lowerCAmelCase				)


if __name__ == "__main__":
							import doctest

							doctest.testmod()












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]"