
from __future__ import annotations

import math






def   lowerCamelCase__							(					a      )      ->   bool:

   if 1 < number < 4:
      # 2 and 3 are primes
      return True
   elif number < 2 or number % 2 == 0 or number % 3 == 0:
      # Negatives, 0, 1, all even numbers, all multiples of 3 are not primes
      return False

   # All primes number are in format of 6k +/- 1
   for i in range(5		,		int(math.sqrt(a      ) + 1      )		,		6      ):
      if number % i == 0 or number % (i + 2) == 0:
         return False
   return True


UpperCAmelCase__		:     Optional[int]     			=      [num for num in range(3, 100001, 2) if not is_prime(num)]






def   lowerCamelCase__							(					a      )      ->   list[int]:
   if not isinstance(a		,		a      ):
      raise ValueError('''n must be an integer'''      )
   if n <= 0:
      raise ValueError('''n must be >= 0'''      )

   _A:  Dict					=       []
   for num in range(len(a      )      ):
      _A:  int					=       0
      while 2 * i * i <= odd_composites[num]:
         _A:  Union[str, Any]					=       odd_composites[num] - 2 * i * i
         if is_prime(a      ):
            break
         i += 1
      else:
         list_nums.append(odd_composites[num]      )
         if len(a      ) == n:
            return list_nums

   return []






def   lowerCamelCase__							(					)      ->   int:
   return compute_nums(1      )[0]


if __name__ == "__main__":
   print(F"""{solution() = }""")





from __future__ import annotations

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

UpperCAmelCase__		:     Union[str, Any]     			=      TypeVar('T')






class UpperCAmelCase   (						Generic[T]   ):





   '''simple docstring'''
   __UpperCamelCase		:    deque[T]  # Cache store of keys
   __UpperCamelCase		:    set[T]  # References of the keys in cache
   __UpperCamelCase		:    int 				=    10  # Maximum capacity of cache


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

      """simple docstring"""
      _A:  Tuple					=       deque()
      _A:  List[Any]					=       set()
      if not n:
         _A:  str					=       sys.maxsize
      elif n < 0:
         raise ValueError('''n should be an integer greater than 0.'''     )
      else:
         _A:  Dict					=       n


   def  __magic_name__				(					self     :							Optional[int]			,			lowerCAmelCase_     :							T     ):

      """simple docstring"""
      if x not in self.key_reference:
         if len(self.dq_store     ) == LRUCache._MAX_CAPACITY:
            _A:  Optional[Any]					=       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  __magic_name__				(					self     :							Optional[Any]     ):

      """simple docstring"""
      for k in self.dq_store:
         print(lowerCAmelCase_     )


   def __repr__(					self     :							Dict     ):

      """simple docstring"""
      return F"""LRUCache({self._MAX_CAPACITY}) => {list(self.dq_store     )}"""


if __name__ == "__main__":
   import doctest

   doctest.testmod()

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



