


'''simple docstring'''
from __future__ import annotations

from functools import lru_cache
from math import ceil

UpperCAmelCase_			:  int										=   1_0_0

UpperCAmelCase_			:  str										=   set(range(3, NUM_PRIMES, 2))
primes.add(2)
UpperCAmelCase_			:  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       _lowercase							(					UpperCamelCase__							:       int      ):
 if number_to_partition < 0:
  return set()
 elif number_to_partition == 0:
  return {1}

 __A	:		set[int]	  =      set()
 __A	:		int
 __A	:		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       _lowercase							(					UpperCamelCase__							:       int = 5000      ):
 for number_to_partition in range(1,					UpperCamelCase__      ):
  if len(partition(UpperCamelCase__      )      ) > number_unique_partitions:
   return number_to_partition
 return None


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










'''simple docstring'''
def       _lowercase							(					UpperCamelCase__							:       dict      ):
 __A	:		Dict	  =      set()
 # edges = list of graph's edges
 __A	:		Any	  =      get_edges(UpperCamelCase__      )

 # While there are still elements in edges list, take an arbitrary edge
 # (from_node, to_node) and add his extremity to chosen_vertices and then
 # remove all arcs adjacent to the from_node and to_node
 while edges:
  __A  ,__A	:		List[Any]	  =      edges.pop()
  chosen_vertices.add(UpperCamelCase__      )
  chosen_vertices.add(UpperCamelCase__      )
  for edge in edges.copy():
   if from_node in edge or to_node in edge:
    edges.discard(UpperCamelCase__      )
 return chosen_vertices


def       _lowercase							(					UpperCamelCase__							:       dict      ):
 __A	:		Any	  =      set()
 for from_node, to_nodes in graph.items():
  for to_node in to_nodes:
   edges.add((from_node, to_node)      )
 return edges


if __name__ == "__main__":
 import doctest

 doctest.testmod()

 # graph = {0: [1, 3], 1: [0, 3], 2: [0, 3, 4], 3: [0, 1, 2], 4: [2, 3]}
 # print(f"Matching vertex cover:\n{matching_min_vertex_cover(graph)}")






