






from __future__ import annotations

from functools import lru_cache
from math import ceil

lowercase  							=					100

lowercase  							=					set(range(3, NUM_PRIMES, 2))
primes.add(2)
lowercase  							=					42

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=1_00)
def 						__UpperCAmelCase			(     a_):
							if number_to_partition < 0:
														return set()
							elif number_to_partition == 0:
														return {1}

							snake_case_				=							set()
							snake_case_				=							42
							snake_case_				=							42

							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 						__UpperCAmelCase			(     a_ = 50_00):
							for number_to_partition in range(1							,     a_):
														if len(partition(a_)) > number_unique_partitions:
																					return number_to_partition
							return None


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













class  UpperCamelCase_      :



	'''simple docstring'''




	def __init__(       self       ,			a					)       ->    None:
								snake_case_				=							set_counts
								snake_case_				=							max(a					)
								snake_case_				=							len(a					)
								snake_case_				=							[1] * num_sets
								snake_case_				=							list(range(a					)					)




	def 							_UpperCamelCase			(       self       ,			a       ,			a					)       ->    bool:
								snake_case_				=							self.get_parent(a					)
								snake_case_				=							self.get_parent(a					)

								if src_parent == dst_parent:
															return False

								if self.ranks[dst_parent] >= self.ranks[src_parent]:
															self.set_counts[dst_parent] += self.set_counts[src_parent]
															snake_case_				=							0
															snake_case_				=							dst_parent
															if self.ranks[dst_parent] == self.ranks[src_parent]:
																						self.ranks[dst_parent] += 1
															snake_case_				=							self.set_counts[dst_parent]
								else:
															self.set_counts[src_parent] += self.set_counts[dst_parent]
															snake_case_				=							0
															snake_case_				=							src_parent
															snake_case_				=							self.set_counts[src_parent]

								snake_case_				=							max(self.max_set       ,			a					)
								return True






	def 							_UpperCamelCase			(       self       ,			a					)       ->    int:
								if self.parents[disj_set] == disj_set:
															return disj_set
								snake_case_				=							self.get_parent(self.parents[disj_set]					)
								return self.parents[disj_set]





