
"""simple docstring"""




from collections.abc import Callable

class 		a__						:
   def __init__(			self	,    _a = None				):
          # Stores actual heap items.
          lowercase    :				list       		=							[]
          # Stores indexes of each item for supporting updates and deletion.
          lowercase    :				dict       		=							{}
          # Stores current size of heap.
          lowercase    :				Optional[int]       		=							0
          # Stores function used to evaluate the score of an item on which basis ordering
          # will be done.
          lowercase    :				str       		=							key or (lambda _a				: x)
   def 			__magic_name__			(			self	,    _a				):
          return int((i - 1) / 2				) if i > 0 else None
   def 			__magic_name__			(			self	,    _a				):
          lowercase    :				str       		=							int(2 * i + 1				)
          return left if 0 < left < self.size else None
   def 			__magic_name__			(			self	,    _a				):
          lowercase    :				Optional[Any]       		=							int(2 * i + 2				)
          return right if 0 < right < self.size else None
   def 			__magic_name__			(			self	,    _a	,    _a				):
          lowercase		,    lowercase    :				Optional[int]       		=							(
              self.pos_map[self.arr[j][0]],
              self.pos_map[self.arr[i][0]],
          )
          # Then swap the items in the list.
          lowercase		,    lowercase    :				int       		=							self.arr[j], self.arr[i]
   def 			__magic_name__			(			self	,    _a	,    _a				):
          return self.arr[i][1] < self.arr[j][1]
   def 			__magic_name__			(			self	,    _a				):
          lowercase    :				Optional[Any]       		=							self._left(_a				)
          lowercase    :				Any       		=							self._right(_a				)
          lowercase    :				str       		=							i

          if left is not None and not self._cmp(_a	,    _a				):
                 lowercase    :				Optional[Any]       		=							left
          if right is not None and not self._cmp(_a	,    _a				):
                 lowercase    :				Optional[Any]       		=							right

          return valid_parent
   def 			__magic_name__			(			self	,    _a				):
          lowercase    :				Optional[Any]       		=							self._parent(_a				)
          while parent is not None and not self._cmp(_a	,    _a				):
                 self._swap(_a	,    _a				)
                 lowercase		,    lowercase    :				Optional[int]       		=							parent, self._parent(_a				)
   def 			__magic_name__			(			self	,    _a				):
          lowercase    :				Dict       		=							self._get_valid_parent(_a				)
          while valid_parent != index:
                 self._swap(_a	,    _a				)
                 lowercase		,    lowercase    :				List[str]       		=							valid_parent, self._get_valid_parent(_a				)
   def 			__magic_name__			(			self	,    _a	,    _a				):
          if item not in self.pos_map:
                 return
          lowercase    :				Dict       		=							self.pos_map[item]
          lowercase    :				Optional[int]       		=							[item, self.key(_a				)]
          # Make sure heap is right in both up and down direction.
          # Ideally only one of them will make any change.
          self._heapify_up(_a				)
          self._heapify_down(_a				)
   def 			__magic_name__			(			self	,    _a				):
          if item not in self.pos_map:
                 return
          lowercase    :				Optional[Any]       		=							self.pos_map[item]
          del self.pos_map[item]
          lowercase    :				Union[str, Any]       		=							self.arr[self.size - 1]
          lowercase    :				List[str]       		=							index
          self.size -= 1
          # Make sure heap is right in both up and down direction. Ideally only one
          # of them will make any change- so no performance loss in calling both.
          if self.size > index:
                 self._heapify_up(_a				)
                 self._heapify_down(_a				)
   def 			__magic_name__			(			self	,    _a	,    _a				):
          lowercase    :				List[str]       		=							len(self.arr				)
          if arr_len == self.size:
                 self.arr.append([item, self.key(_a				)]				)
          else:
                 lowercase    :				str       		=							[item, self.key(_a				)]
          lowercase    :				str       		=							self.size
          self.size += 1
          self._heapify_up(self.size - 1				)
   def 			__magic_name__			(			self				):
          return self.arr[0] if self.size else None

   def 			__magic_name__			(			self				):
          lowercase    :				Optional[Any]       		=							self.get_top()
          if top_item_tuple:
                 self.delete_item(top_item_tuple[0]				)
          return top_item_tuple


def   __magic_name__	(      ) ->				None:
       pass


if __name__ == "__main__":
   import doctest

   doctest.testmod()




"""simple docstring"""




from __future__ import annotations

from functools import lru_cache
from math import ceil

_A			:       Optional[Any]   		=       1_00

_A			:       Optional[int]   		=       set(range(3, NUM_PRIMES, 2))
primes.add(2)
_A			:       int

for prime in range(3, ceil(NUM_PRIMES**0.5), 2):
   if prime not in primes:
      continue
   primes.difference_update(set(range(prime * prime, NUM_PRIMES, prime)))


@lru_cache(maxsize=100  )
def   __magic_name__	(      __snake_case				:       int  ) ->				set[int]:
       if number_to_partition < 0:
              return set()
       elif number_to_partition == 0:
              return {1}

       lowercase    :				set[int]       		=							set()
       lowercase    :				int
       lowercase    :				int

       for prime in primes:
              if prime > number_to_partition:
                     continue
              for sub in partition(number_to_partition - prime  ):
                     ret.add(sub * prime  )

       return ret


def   __magic_name__	(      __snake_case				:       int = 5000  ) ->				int | None:
       for number_to_partition in range(1     , __snake_case  ):
              if len(partition(__snake_case  )  ) > number_unique_partitions:
                     return number_to_partition
       return None


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


