





from __future__ import annotations

from functools import lru_cache
from math import ceil

UpperCAmelCase	:	Optional[Any]		     =       100

UpperCAmelCase	:	Optional[int]		     =       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      _A       (		SCREAMING_SNAKE_CASE     :   int						):





  """simple docstring"""



  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      _A       (		SCREAMING_SNAKE_CASE     :   int = 5_000						):





  """simple docstring"""



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








"""simple docstring"""




import os
import unittest

from transformers.models.cpmant.tokenization_cpmant import VOCAB_FILES_NAMES, CpmAntTokenizer
from transformers.testing_utils import require_jieba, tooslow

from ...test_tokenization_common import TokenizerTesterMixin

@require_jieba
class 		a__						(      a_,			unittest.TestCase						):
   __lowerCAmelCase            =				CpmAntTokenizer
   __lowerCAmelCase            =				False
   def 			__magic_name__			(			self				):
          super().setUp()

          lowercase    :				List[str]       		=							[
              "<d>",
              "</d>",
              "<s>",
              "</s>",
              "</_>",
              "<unk>",
              "<pad>",
              "</n>",
              "我",
              "是",
              "C",
              "P",
              "M",
              "A",
              "n",
              "t",
          ]
          lowercase    :				Dict       		=							os.path.join(self.tmpdirname	,    VOCAB_FILES_NAMES["vocab_file"]				)
          with open(self.vocab_file	,    "w"	,    encoding="utf-8"				) as vocab_writer:
                 vocab_writer.write("".join([x + "\n" for x in vocab_tokens]				)				)

   @tooslow
   def 			__magic_name__			(			self				):
          lowercase    :				Tuple       		=							CpmAntTokenizer.from_pretrained("openbmb/cpm-ant-10b"				)
          lowercase    :				str       		=							"今天天气真好！"
          lowercase    :				Optional[int]       		=							["今天", "天气", "真", "好", "！"]
          lowercase    :				int       		=							tokenizer.tokenize(_a				)
          self.assertListEqual(_a	,    _a				)
          lowercase    :				Any       		=							"今天天气真好！"
          lowercase    :				int       		=							[tokenizer.bos_token] + tokens

          lowercase    :				List[str]       		=							[6, 9_802, 14_962, 2_082, 831, 244]
          self.assertListEqual(tokenizer.convert_tokens_to_ids(_a				)	,    _a				)

          lowercase    :				str       		=							tokenizer.decode(_a				)
          self.assertEqual(_a	,    _a				)


