





from collections import defaultdict







class     __snake_case       :





       '''simple docstring'''







       def __init__(  self :    Union[str, Any]							,				A :    Tuple							,				A :    int		):
         __snake_case:						Union[str, Any]   =						total  # total no of tasks (N)

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

         __snake_case:						Union[str, Any]   =						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
         __snake_case:						Optional[Any]   =						(1 << len(A		)) - 1




       def 							UpperCAmelCase__ (  self :    List[Any]							,				A :    Union[str, Any]							,				A :    Any		):
         # 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
         __snake_case:						Optional[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.
         __snake_case:						Any   =						total_ways_util

         return self.dp[mask][task_no]






       def 							UpperCAmelCase__ (  self :    Optional[int]							,				A :    Optional[Any]		):
         # 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__":
      __UpperCAmelCase       :   Dict				       =							5  # total no of tasks (the value of N)

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













__UpperCAmelCase       :   int				       =							[
    "Audio",
    "Array2D",
    "Array3D",
    "Array4D",
    "Array5D",
    "ClassLabel",
    "Features",
    "Sequence",
    "Value",
    "Image",
    "Translation",
    "TranslationVariableLanguages",
]
from .audio import Audio
from .features import ArrayaD, ArrayaD, ArrayaD, ArrayaD, ClassLabel, Features, Sequence, Value
from .image import Image
from .translation import Translation, TranslationVariableLanguages






