





import os
import sys

__lowerCamelCase       :     Any   =     os.path.join(os.path.dirname(__file__), """src""")
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


__lowerCamelCase       :     Dict   =     [
    """torch""",
    """numpy""",
    """tokenizers""",
    """filelock""",
    """requests""",
    """tqdm""",
    """regex""",
    """sentencepiece""",
    """sacremoses""",
    """importlib_metadata""",
    """huggingface_hub""",
]



@add_start_docstrings(AutoConfig.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> List[str]:
 return AutoConfig.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )



@add_start_docstrings(AutoTokenizer.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> List[Any]:
 return AutoTokenizer.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )



@add_start_docstrings(AutoModel.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> Union[str, Any]:
 return AutoModel.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )



@add_start_docstrings(AutoModelForCausalLM.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> Tuple:
 return AutoModelForCausalLM.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )



@add_start_docstrings(AutoModelForMaskedLM.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> List[Any]:
 return AutoModelForMaskedLM.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )



@add_start_docstrings(AutoModelForSequenceClassification.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> int:
 return AutoModelForSequenceClassification.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )



@add_start_docstrings(AutoModelForQuestionAnswering.__doc__     )
def 		A_				(     *_lowerCAmelCase							,   **_lowerCAmelCase     )						-> int:
 return AutoModelForQuestionAnswering.from_pretrained(*_lowerCAmelCase							,   **_lowerCAmelCase     )







from __future__ import annotations

from functools import lru_cache
from math import ceil

__lowerCamelCase       :     str   =     100

__lowerCamelCase       :     Any   =     set(range(3, NUM_PRIMES, 2))
primes.add(2)
__lowerCamelCase       :     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 		A_				(     _lowerCAmelCase     )						-> set[int]:
 if number_to_partition < 0:
  return set()
 elif number_to_partition == 0:
  return {1}

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


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