
"""simple docstring"""




from math import factorial, pi


def   __magic_name__	(      __snake_case				:       float     , __snake_case				:       int = 30  ) ->				float:

       if not isinstance(__snake_case     , (int, float)  ):
              raise ValueError("maclaurin_sin() requires either an int or float for theta"  )

       if not isinstance(__snake_case     , __snake_case  ) or accuracy <= 0:
              raise ValueError("maclaurin_sin() requires a positive int for accuracy"  )

       lowercase    :				Optional[int]       		=							float(__snake_case  )
       lowercase    :				Union[str, Any]       		=							theta // (2 * pi)
       theta -= 2 * div * pi
       return sum(
           (-1) ** r * theta ** (2 * r + 1) / factorial(2 * r + 1  ) for r in range(__snake_case  )  )


def   __magic_name__	(      __snake_case				:       float     , __snake_case				:       int = 30  ) ->				float:

       if not isinstance(__snake_case     , (int, float)  ):
              raise ValueError("maclaurin_cos() requires either an int or float for theta"  )

       if not isinstance(__snake_case     , __snake_case  ) or accuracy <= 0:
              raise ValueError("maclaurin_cos() requires a positive int for accuracy"  )

       lowercase    :				str       		=							float(__snake_case  )
       lowercase    :				List[Any]       		=							theta // (2 * pi)
       theta -= 2 * div * pi
       return sum((-1) ** r * theta ** (2 * r) / factorial(2 * r  ) for r in range(__snake_case  )  )


if __name__ == "__main__":
   import doctest

   doctest.testmod()

   print(maclaurin_sin(10))
   print(maclaurin_sin(-10))
   print(maclaurin_sin(10, 15))
   print(maclaurin_sin(-10, 15))

   print(maclaurin_cos(5))
   print(maclaurin_cos(-5))
   print(maclaurin_cos(10, 15))
   print(maclaurin_cos(-10, 15))




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


