



'''simple docstring'''






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

lowerCAmelCase:      Optional[int]		 =		TypeVar('KEY')
lowerCAmelCase:      Tuple		 =		TypeVar('VAL')

@dataclass(frozen=lowerCamelCase__	,				slots=lowerCamelCase__			)
class 							a__(      Generic[KEY, VAL]			):
    _a				=					42
    _a				=					42

class 							a__(      _Item			):







    def __init__(   self				:						Any			):
      super().__init__(__snake_case		,    __snake_case			)







    def __bool__(   self				:						int			):
      return False
lowerCAmelCase:      Any		 =		_DeletedItem()

class 							a__(      MutableMapping[KEY, VAL]			):







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







    def     lowercase_ (   self				:						Any		,    __snake_case				:						KEY			):
      return hash(__snake_case			) % len(self._buckets			)







    def     lowercase_ (   self				:						Optional[Any]		,    __snake_case				:						int			):
      return (ind + 1) % len(self._buckets			)







    def     lowercase_ (   self				:						Union[str, Any]		,    __snake_case				:						int		,    __snake_case				:						KEY		,    __snake_case				:						VAL			):
      a		:      List[str]       =  self._buckets[ind]
      if not stored:
        a		:      Optional[int]       =  _Item(__snake_case		,    __snake_case			)
        self._len += 1
        return True
      elif stored.key == key:
        a		:      Optional[int]       =  _Item(__snake_case		,    __snake_case			)
        return True
      else:
        return False







    def     lowercase_ (   self				:						Union[str, Any]			):
      a		:      Any       =  len(self._buckets			) * self._capacity_factor
      return len(self			) >= int(__snake_case			)







    def     lowercase_ (   self				:						Dict			):
      if len(self._buckets			) <= self._initial_block_size:
        return False
      a		:      str       =  len(self._buckets			) * self._capacity_factor / 2
      return len(self			) < limit







    def     lowercase_ (   self				:						Optional[Any]		,    __snake_case				:						int			):
      a		:      Tuple       =  self._buckets
      a		:      Any       =  [None] * new_size
      a		:      Tuple       =  0
      for item in old_buckets:
        if item:
          self._add_item(item.key		,    item.val			)







    def     lowercase_ (   self				:						Tuple			):
      self._resize(len(self._buckets			) * 2			)







    def     lowercase_ (   self				:						Dict			):
      self._resize(len(self._buckets			) // 2			)







    def     lowercase_ (   self				:						List[str]		,    __snake_case				:						KEY			):
      a		:      Tuple       =  self._get_bucket_index(__snake_case			)
      for _ in range(len(self._buckets			)			):
        yield ind
        a		:      str       =  self._get_next_ind(__snake_case			)







    def     lowercase_ (   self				:						Any		,    __snake_case				:						KEY		,    __snake_case				:						VAL			):
      for ind in self._iterate_buckets(__snake_case			):
        if self._try_set(__snake_case		,    __snake_case		,    __snake_case			):
          break







    def __setitem__(   self				:						str		,    __snake_case				:						KEY		,    __snake_case				:						VAL			):
      if self._is_full():
        self._size_up()

      self._add_item(__snake_case		,    __snake_case			)







    def __delitem__(   self				:						str		,    __snake_case				:						KEY			):
      for ind in self._iterate_buckets(__snake_case			):
        a		:      Optional[Any]       =  self._buckets[ind]
        if item is None:
          raise KeyError(__snake_case			)
        if item is _deleted:
          continue
        if item.key == key:
          a		:      str       =  _deleted
          self._len -= 1
          break
      if self._is_sparse():
        self._size_down()







    def __getitem__(   self				:						Optional[int]		,    __snake_case				:						KEY			):
      for ind in self._iterate_buckets(__snake_case			):
        a		:      Dict       =  self._buckets[ind]
        if item is None:
          break
        if item is _deleted:
          continue
        if item.key == key:
          return item.val
      raise KeyError(__snake_case			)







    def __len__(   self				:						Tuple			):
      return self._len







    def __iter__(   self				:						Union[str, Any]			):
      yield from (item.key for item in self._buckets if item)







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




'''simple docstring'''






def    lowerCamelCase__ (		_A = 6008_5147_5143       ):

  try:
    a		:      Optional[int]       =  int(_A       )
  except (TypeError, ValueError):
    raise TypeError('Parameter n must be int or castable to int.'       )
  if n <= 0:
    raise ValueError('Parameter n must be greater than or equal to one.'       )
  a		:      Any       =  1
  a		:      Union[str, Any]       =  2
  while i * i <= n:
    while n % i == 0:
      a		:      str       =  i
      n //= i
    i += 1
  if n > 1:
    a		:      Any       =  n
  return int(_A       )


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