


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

UpperCAmelCase_				:			List[str]   =	TypeVar('KEY')
UpperCAmelCase_				:			List[str]   =	TypeVar('VAL')
@dataclass(frozen=lowercase__						,   slots=lowercase__      )
class 			SCREAMING_SNAKE_CASE__  (    Generic[KEY, VAL]      ):
      snake_case__    :					KEY
      snake_case__    :					VAL
class 			SCREAMING_SNAKE_CASE__  (    _Item      ):
      def __init__(	self    :	str					)		->      None:
             super().__init__(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)

      def __bool__(	self    :	Optional[int]					)		->      bool:
             return False
UpperCAmelCase_				:			Optional[Any]   =	_DeletedItem()
class 			SCREAMING_SNAKE_CASE__  (    MutableMapping[KEY, VAL]      ):
      def __init__(	self    :	Optional[Any]					,							SCREAMING_SNAKE_CASE__    :	int = 8					,							SCREAMING_SNAKE_CASE__    :	float = 0.75					)		->      None:
             a_ :		int							=  initial_block_size
             a_ :		list[_Item | None]							=  [None] * initial_block_size
             assert 0.0 < capacity_factor < 1.0
             a_ :		Optional[int]							=  capacity_factor
             a_ :		Union[str, Any]							=  0
      def 	SCREAMING_SNAKE_CASE							(	self    :	Tuple					,							SCREAMING_SNAKE_CASE__    :	KEY					)		->      int:
             return hash(SCREAMING_SNAKE_CASE__					) % len(self._buckets					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	str					,							SCREAMING_SNAKE_CASE__    :	int					)		->      int:
             return (ind + 1) % len(self._buckets					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Tuple					,							SCREAMING_SNAKE_CASE__    :	int					,							SCREAMING_SNAKE_CASE__    :	KEY					,							SCREAMING_SNAKE_CASE__    :	VAL					)		->      bool:
             a_ :		Dict							=  self._buckets[ind]
             if not stored:
                    a_ :		str							=  _Item(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
                    self._len += 1
                    return True
             elif stored.key == key:
                    a_ :		Tuple							=  _Item(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
                    return True
             else:
                    return False
      def 	SCREAMING_SNAKE_CASE							(	self    :	Tuple					)		->      bool:
             a_ :		Optional[int]							=  len(self._buckets					) * self._capacity_factor
             return len(self					) >= int(SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					)		->      bool:
             if len(self._buckets					) <= self._initial_block_size:
                    return False
             a_ :		Tuple							=  len(self._buckets					) * self._capacity_factor / 2
             return len(self					) < limit
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[Any]					,							SCREAMING_SNAKE_CASE__    :	int					)		->      None:
             a_ :		str							=  self._buckets
             a_ :		Optional[int]							=  [None] * new_size
             a_ :		int							=  0
             for item in old_buckets:
                    if item:
                           self._add_item(item.key					,							item.val					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					)		->      None:
             self._resize(len(self._buckets					) * 2					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	List[str]					)		->      None:
             self._resize(len(self._buckets					) // 2					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Dict					,							SCREAMING_SNAKE_CASE__    :	KEY					)		->      Iterator[int]:
             a_ :		Union[str, Any]							=  self._get_bucket_index(SCREAMING_SNAKE_CASE__					)
             for _ in range(len(self._buckets					)					):
                    yield ind
                    a_ :		List[Any]							=  self._get_next_ind(SCREAMING_SNAKE_CASE__					)
      def 	SCREAMING_SNAKE_CASE							(	self    :	Optional[int]					,							SCREAMING_SNAKE_CASE__    :	KEY					,							SCREAMING_SNAKE_CASE__    :	VAL					)		->      None:
             for ind in self._iterate_buckets(SCREAMING_SNAKE_CASE__					):
                    if self._try_set(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					):
                           break
      def __setitem__(	self    :	int					,							SCREAMING_SNAKE_CASE__    :	KEY					,							SCREAMING_SNAKE_CASE__    :	VAL					)		->      None:
             if self._is_full():
                    self._size_up()

             self._add_item(SCREAMING_SNAKE_CASE__					,							SCREAMING_SNAKE_CASE__					)
      def __delitem__(	self    :	Optional[int]					,							SCREAMING_SNAKE_CASE__    :	KEY					)		->      None:
             for ind in self._iterate_buckets(SCREAMING_SNAKE_CASE__					):
                    a_ :		List[str]							=  self._buckets[ind]
                    if item is None:
                           raise KeyError(SCREAMING_SNAKE_CASE__					)
                    if item is _deleted:
                           continue
                    if item.key == key:
                           a_ :		int							=  _deleted
                           self._len -= 1
                           break
             if self._is_sparse():
                    self._size_down()
      def __getitem__(	self    :	Optional[int]					,							SCREAMING_SNAKE_CASE__    :	KEY					)		->      VAL:
             for ind in self._iterate_buckets(SCREAMING_SNAKE_CASE__					):
                    a_ :		int							=  self._buckets[ind]
                    if item is None:
                           break
                    if item is _deleted:
                           continue
                    if item.key == key:
                           return item.val
             raise KeyError(SCREAMING_SNAKE_CASE__					)
      def __len__(	self    :	str					)		->      int:
             return self._len
      def __iter__(	self    :	Optional[int]					)		->      Iterator[KEY]:
             yield from (item.key for item in self._buckets if item)

      def __repr__(	self    :	Optional[int]					)		->      str:
             a_ :		Optional[Any]							=  ' ,'.join(
                 F"""{item.key}: {item.val}""" for item in self._buckets if item					)
             return F"""HashMap({val_string})"""






from __future__ import annotations

UpperCAmelCase_				:			Dict   =	[True] * 100_0001
UpperCAmelCase_				:			Any   =	2
while i * i <= 100_0000:
   if seive[i]:
      for j in range(i * i, 100_0001, i):
         UpperCAmelCase_				:			Tuple   =	False
   i += 1







def 	SCREAMING_SNAKE_CASE_						(      __A			:      int    )     ->		bool:

       """simple docstring"""

       return seive[n]







def 	SCREAMING_SNAKE_CASE_						(      __A			:      int    )     ->		bool:

       """simple docstring"""

       return any(digit in '02468' for digit in str(__A    )    )







def 	SCREAMING_SNAKE_CASE_						(      __A			:      int = 1_00_00_00    )     ->		list[int]:

       """simple docstring"""

       a_ :		Dict							=  [2]  # result already includes the number 2.
       for num in range(3  ,   limit + 1  ,   2    ):
              if is_prime(__A    ) and not contains_an_even_digit(__A    ):
                     a_ :		Dict							=  str(__A    )
                     a_ :		Any							=  [int(str_num[j:] + str_num[:j]    ) for j in range(len(__A    )    )]
                     if all(is_prime(__A    ) for i in list_nums    ):
                            result.append(__A    )
       return result







def 	SCREAMING_SNAKE_CASE_						(      )     ->		int:

       """simple docstring"""

       return len(find_circular_primes()    )


if __name__ == "__main__":
   print(F'{len(find_circular_primes()) = }')


