






'''simple docstring'''





def __UpperCAmelCase					( A :       int						)  ->					bool:

			if p < 2:
						raise ValueError('''p should not be less than 2!'''						)
			elif p == 2:
						return True

			UpperCAmelCase_	:    Dict	  =    4
			UpperCAmelCase_	:    str	  =    (1 << p) - 1
			for _ in range(p - 2						):
						UpperCAmelCase_	:    Optional[Any]	  =    ((s * s) - 2) % m
			return s == 0


if __name__ == "__main__":
						print(lucas_lehmer_test(7))
						print(lucas_lehmer_test(11))




"""simple docstring"""




from __future__ import annotations

from functools import lru_cache
from math import ceil

_A			:       Optional[Any]   		=       1_00

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

       lowercase    :				set[int]       		=							set()
       lowercase    :				int
       lowercase    :				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   __magic_name__	(      __snake_case				:       int = 5000  ) ->				int | None:
       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() = }")


