





from collections import defaultdict



class 							_UpperCamelCase					:

       def __init__(		self: List[Any]					,   _SCREAMING_SNAKE_CASE: int					,   _SCREAMING_SNAKE_CASE: Optional[int]		)       -> Tuple:




              """simple docstring"""


              UpperCamelCase_          =  total  # total no of tasks (N)

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

              UpperCamelCase_          =  defaultdict(_SCREAMING_SNAKE_CASE		)  # 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
              UpperCamelCase_          =  (1 << len(_SCREAMING_SNAKE_CASE		)) - 1

       def lowercase (		self: List[str]					,   _SCREAMING_SNAKE_CASE: Any					,   _SCREAMING_SNAKE_CASE: Any		)       -> Tuple:




              """simple docstring"""


              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
              UpperCamelCase_          =  self.count_ways_until(_SCREAMING_SNAKE_CASE					,   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.
              UpperCamelCase_          =  total_ways_util

              return self.dp[mask][task_no]



       def lowercase (		self: List[str]					,   _SCREAMING_SNAKE_CASE: Union[str, Any]		)       -> int:




              """simple docstring"""


              for i in range(len(_SCREAMING_SNAKE_CASE		)		):
                     for j in task_performed[i]:
                            self.task[j].append(_SCREAMING_SNAKE_CASE		)

        # 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        =				5  # total no of tasks (the value of N)

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








import random
from typing import Any




def  lowerCAmelCase_ (							UpperCamelCase_  )     ->		list[Any]:
       for _ in range(len(UpperCamelCase_  )  ):
              UpperCamelCase_          =  random.randint(0					,		len(UpperCamelCase_  ) - 1  )
              UpperCamelCase_          =  random.randint(0					,		len(UpperCamelCase_  ) - 1  )
              UpperCamelCase_       , UpperCamelCase_          =  data[b], data[a]
       return data


if __name__ == "__main__":
     _UpperCAmelCase        =				[0, 1, 2, 3, 4, 5, 6, 7]
     _UpperCAmelCase        =				['python', 'says', 'hello', '!']
     print('Fisher-Yates Shuffle:')
     print('List', integers, strings)
     print('FY Shuffle', fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))

