
"""simple docstring"""




from collections import defaultdict

class 		a__						:
   def __init__(			self	,    _a	,    _a				):
          lowercase    :				List[Any]       		=							total  # total no of tasks (N)

          # DP table will have a dimension of (2^M)*N
          # initially all values are set to -1
          lowercase    :				int       		=							[
              [-1 for i in range(total + 1				)] for j in range(2 ** len(_a				)				)
          ]

          lowercase    :				int       		=							defaultdict(_a				)  # stores the list of persons for each task

          # final_mask is used to check if all persons are included by setting all bits
          # to 1
          lowercase    :				int       		=							(1 << len(_a				)) - 1
   def 			__magic_name__			(			self	,    _a	,    _a				):
          # if mask == self.finalmask all persons are distributed tasks, return 1
          if mask == self.final_mask:
                 return 1

          # if not everyone gets the task and no more tasks are available, return 0
          if task_no > self.total_tasks:
                 return 0

          # if case already considered
          if self.dp[mask][task_no] != -1:
                 return self.dp[mask][task_no]

          # Number of ways when we don't this task in the arrangement
          lowercase    :				Any       		=							self.count_ways_until(_a	,    task_no + 1				)

          # now assign the tasks one by one to all possible persons and recursively
          # assign for the remaining tasks.
          if task_no in self.task:
                 for p in self.task[task_no]:
                        # if p is already given a task
                        if mask & (1 << p):
                               continue

                        # assign this task to p and change the mask value. And recursively
                        # assign tasks with the new mask value.
                        total_ways_util += self.count_ways_until(mask | (1 << p)	,    task_no + 1				)

        # save the value.
          lowercase    :				str       		=							total_ways_util

          return self.dp[mask][task_no]

   def 			__magic_name__			(			self	,    _a				):
          # Store the list of persons for each task
          for i in range(len(_a				)				):
                 for j in task_performed[i]:
                        self.task[j].append(_a				)

        # call the function to fill the DP table, final answer is stored in dp[0][1]
          return self.count_ways_until(0	,    1				)


if __name__ == "__main__":
   _A			:       Union[str, Any]   		=       5  # total no of tasks (the value of N)

   # the list of tasks that can be done by M persons.
   _A			:       Optional[Any]   		=       [[1, 3, 4], [1, 2, 5], [3, 4]]
   print(
       AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
           task_performed
       )
   )




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


