

from __future__ import annotations

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

_lowerCAmelCase  :      Any			 =TypeVar("""T""")

class __UpperCamelCase     (				Generic[T]		):






					'''simple docstring'''



					__magic_name__        =   42  # Cache store of keys
					__magic_name__        =   42  # References of the keys in cache
					__magic_name__        =   1_0  # Maximum capacity of cache





					def __init__(				self				,      lowerCamelCase__						):
						UpperCAmelCase__:	List[str]									= deque()
						UpperCAmelCase__:	Dict									= set()
						if not n:
							UpperCAmelCase__:	Optional[Any]									= sys.maxsize
						elif n < 0:
							raise ValueError("n should be an integer greater than 0."						)
						else:
							UpperCAmelCase__:	Dict									= n





					def    _UpperCAmelCase    (				self				,      lowerCamelCase__						):
						if x not in self.key_reference:
							if len(self.dq_store						) == LRUCache._MAX_CAPACITY:
								UpperCAmelCase__:	str									= self.dq_store.pop()
								self.key_reference.remove(lowerCamelCase__						)
						else:
							self.dq_store.remove(lowerCamelCase__						)

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





					def    _UpperCAmelCase    (				self						):
						for k in self.dq_store:
							print(lowerCamelCase__						)





					def __repr__(				self						):
						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]"


def 			_A	(      SCREAMING_SNAKE_CASE      ):
	UpperCAmelCase__:	Tuple									= int(SCREAMING_SNAKE_CASE      )
	if decimal in (0, 1):  # Exit cases for the recursion
		return str(SCREAMING_SNAKE_CASE      )
	UpperCAmelCase__							,						UpperCAmelCase__:	Union[str, Any]									= divmod(SCREAMING_SNAKE_CASE	,2      )
	return binary_recursive(SCREAMING_SNAKE_CASE      ) + str(SCREAMING_SNAKE_CASE      )



def 			_A	(      SCREAMING_SNAKE_CASE      ):
	UpperCAmelCase__:	List[str]									= str(SCREAMING_SNAKE_CASE      ).strip()
	if not number:
		raise ValueError("No input value was provided"      )
	UpperCAmelCase__:	Tuple									= "-" if number.startswith("-"      ) else ""
	UpperCAmelCase__:	Any									= number.lstrip("-"      )
	if not number.isnumeric():
		raise ValueError("Input value is not an integer"      )
	return f"{negative}0b{binary_recursive(int(SCREAMING_SNAKE_CASE      )      )}"


if __name__ == "__main__":
					from doctest import testmod

					testmod()