



from __future__ import annotations

from functools import lru_cache
from math import ceil

UpperCAmelCase__       =	100

UpperCAmelCase__       =	set(range(3, NUM_PRIMES, 2))
primes.add(2)
UpperCAmelCase__       =	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=100   )
def 							A     (					_UpperCAmelCase    :       int   )    ->			set[int]:







			'''simple docstring'''
			if number_to_partition < 0:
						return set()
			elif number_to_partition == 0:
						return {1}

			_UpperCAmelCase			=       set()
			_UpperCAmelCase			=       42
			_UpperCAmelCase			=       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 							A     (					_UpperCAmelCase    :       int = 5_000   )    ->			int | None:







			'''simple docstring'''
			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() = }""")





from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


UpperCAmelCase__       =	{
    "configuration_mega": ["MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP", "MegaConfig", "MegaOnnxConfig"],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							UpperCAmelCase__       =	[
							    "MEGA_PRETRAINED_MODEL_ARCHIVE_LIST",
							    "MegaForCausalLM",
							    "MegaForMaskedLM",
							    "MegaForMultipleChoice",
							    "MegaForQuestionAnswering",
							    "MegaForSequenceClassification",
							    "MegaForTokenClassification",
							    "MegaModel",
							    "MegaPreTrainedModel",
							]

if TYPE_CHECKING:
							from .configuration_mega import MEGA_PRETRAINED_CONFIG_ARCHIVE_MAP, MegaConfig, MegaOnnxConfig

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_mega import (
														    MEGA_PRETRAINED_MODEL_ARCHIVE_LIST,
														    MegaForCausalLM,
														    MegaForMaskedLM,
														    MegaForMultipleChoice,
														    MegaForQuestionAnswering,
														    MegaForSequenceClassification,
														    MegaForTokenClassification,
														    MegaModel,
														    MegaPreTrainedModel,
														)

else:
							import sys

							UpperCAmelCase__       =	_LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)
