




'''simple docstring'''



from collections import defaultdict







class 		lowercase_   :


   """simple docstring"""

   def __init__(   self :     List[str]  ,				__lowerCamelCase :     List[Any]  ,				__lowerCamelCase :     Optional[int]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				total  # total no of tasks (N)

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

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



   def 							lowerCAmelCase_      (   self :     Optional[Any]  ,				__lowerCamelCase :     Optional[Any]  ,				__lowerCamelCase :     Optional[Any]   ):

      """simple docstring"""
      # 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
      _SCREAMING_SNAKE_CASE	=				self.count_ways_until(__lowerCamelCase  ,				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.
      _SCREAMING_SNAKE_CASE	=				total_ways_util

      return self.dp[mask][task_no]



   def 							lowerCAmelCase_      (   self :     Any  ,				__lowerCamelCase :     str   ):

      """simple docstring"""
      # Store the list of persons for each task
      for i in range(len(__lowerCamelCase   )   ):
         for j in task_performed[i]:
            self.task[j].append(__lowerCamelCase   )

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

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







'''simple docstring'''



lowerCamelCase_			=						'Tobias Carryer'

from time import time







class 		lowercase_   :


   """simple docstring"""

   def __init__(   self :     Tuple  ,				__lowerCamelCase :     int  ,				__lowerCamelCase :     List[Any]  ,				__lowerCamelCase :     Optional[int]  ,				__lowerCamelCase :     Dict=int(time()   )   ):  # noqa: B008

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				multiplier
      _SCREAMING_SNAKE_CASE	=				increment
      _SCREAMING_SNAKE_CASE	=				modulo
      _SCREAMING_SNAKE_CASE	=				seed



   def 							lowerCAmelCase_      (   self :     List[str]   ):

      """simple docstring"""
      _SCREAMING_SNAKE_CASE	=				(self.multiplier * self.seed + self.increment) % self.modulo
      return self.seed


if __name__ == "__main__":
 # Show the LCG in action.
 lowerCamelCase_			=						LinearCongruentialGenerator(1_66_45_25, 10_13_90_42_23, 2 << 31)
 while True:
  print(lcg.next_number())

