"""simple docstring"""





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

_UpperCamelCase  :		Union[str, Any]           =       TypeVar("KEY")
_UpperCamelCase  :		str           =       TypeVar("VAL")


@dataclass(frozen=__A					,				slots=__A)
class 	UpperCAmelCase_      (       Generic[KEY, VAL]):
      lowerCamelCase__						:       List[Any]					    =    4_2
      lowerCamelCase__						:       str					    =    4_2





class 	UpperCAmelCase_      (       _Item):


      def __init__(  self				)			->   None:
             super().__init__(a						,     a				)


      def __bool__(  self				)			->   bool:
             return False





_UpperCamelCase  :		Optional[Any]           =       _DeletedItem()


class 	UpperCAmelCase_      (       MutableMapping[KEY, VAL]):


      def __init__(  self						,     a = 8						,     a = 0.75				)			->   None:
             lowercase__     :						int         =      initial_block_size
             lowercase__     :						list[_Item | None]         =      [None] * initial_block_size
             assert 0.0 < capacity_factor < 1.0
             lowercase__     :						List[str]         =      capacity_factor
             lowercase__     :						List[Any]         =      0


      def 						_UpperCAmelCase			(  self						,     a				)			->   int:
             return hash(a				) % len(self._buckets				)


      def 						_UpperCAmelCase			(  self						,     a				)			->   int:
             return (ind + 1) % len(self._buckets				)


      def 						_UpperCAmelCase			(  self						,     a						,     a						,     a				)			->   bool:
             lowercase__     :						Tuple         =      self._buckets[ind]
             if not stored:
                    lowercase__     :						int         =      _Item(a						,     a				)
                    self._len += 1
                    return True
             elif stored.key == key:
                    lowercase__     :						Dict         =      _Item(a						,     a				)
                    return True
             else:
                    return False


      def 						_UpperCAmelCase			(  self				)			->   bool:
             lowercase__     :						int         =      len(self._buckets				) * self._capacity_factor
             return len(self				) >= int(a				)


      def 						_UpperCAmelCase			(  self				)			->   bool:

             if len(self._buckets				) <= self._initial_block_size:
                    return False
             lowercase__     :						Optional[int]         =      len(self._buckets				) * self._capacity_factor / 2
             return len(self				) < limit


      def 						_UpperCAmelCase			(  self						,     a				)			->   None:
             lowercase__     :						Tuple         =      self._buckets
             lowercase__     :						Optional[int]         =      [None] * new_size
             lowercase__     :						Dict         =      0
             for item in old_buckets:
                    if item:
                           self._add_item(item.key						,     item.val				)


      def 						_UpperCAmelCase			(  self				)			->   None:
             self._resize(len(self._buckets				) * 2				)


      def 						_UpperCAmelCase			(  self				)			->   None:
             self._resize(len(self._buckets				) // 2				)


      def 						_UpperCAmelCase			(  self						,     a				)			->   Iterator[int]:
             lowercase__     :						Dict         =      self._get_bucket_index(a				)
             for _ in range(len(self._buckets				)				):
                    yield ind
                    lowercase__     :						int         =      self._get_next_ind(a				)


      def 						_UpperCAmelCase			(  self						,     a						,     a				)			->   None:

             for ind in self._iterate_buckets(a				):
                    if self._try_set(a						,     a						,     a				):
                           break


      def __setitem__(  self						,     a						,     a				)			->   None:

             if self._is_full():
                    self._size_up()

             self._add_item(a						,     a				)


      def __delitem__(  self						,     a				)			->   None:

             for ind in self._iterate_buckets(a				):
                    lowercase__     :						List[str]         =      self._buckets[ind]
                    if item is None:
                           raise KeyError(a				)
                    if item is _deleted:
                           continue
                    if item.key == key:
                           lowercase__     :						int         =      _deleted
                           self._len -= 1
                           break
             if self._is_sparse():
                    self._size_down()


      def __getitem__(  self						,     a				)			->   VAL:

             for ind in self._iterate_buckets(a				):
                    lowercase__     :						List[Any]         =      self._buckets[ind]
                    if item is None:
                           break
                    if item is _deleted:
                           continue
                    if item.key == key:
                           return item.val
             raise KeyError(a				)


      def __len__(  self				)			->   int:
             return self._len


      def __iter__(  self				)			->   Iterator[KEY]:
             yield from (item.key for item in self._buckets if item)


      def __repr__(  self				)			->   str:
             lowercase__     :						int         =      " ,".join(
                 f"""{item.key}: {item.val}""" for item in self._buckets if item				)
             return f"""HashMap({val_string})"""




from __future__ import annotations

def 			lowerCamelCase__			(       _a):
	SCREAMING_SNAKE_CASE :   Optional[Any]					  =							2
	SCREAMING_SNAKE_CASE :   Optional[int]					  =							[]
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(_a)
	if n > 1:
		factors.append(_a)
	return factors


if __name__ == "__main__":
			import doctest

			doctest.testmod()