


from collections import defaultdict


class 			_a				:

							def __init__(				self:      str       ,		UpperCamelCase_:      Any       ,		UpperCamelCase_:      Any				)     ->  Union[str, Any]:





									"""simple docstring"""







									lowercase__				= total  # total no of tasks (N)

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

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

							def  lowerCamelCase_					(				self:      Dict       ,		UpperCamelCase_:      Any       ,		UpperCamelCase_:      Union[str, Any]				)     ->  List[str]:





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

									return self.dp[mask][task_no]


							def  lowerCamelCase_					(				self:      Dict       ,		UpperCamelCase_:      Optional[Any]				)     ->  List[str]:





									"""simple docstring"""







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

        # 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
			    )
			)




from __future__ import annotations

def  __snake_case							(	__magic_name__						):







				'''simple docstring'''


				if len(__magic_name__						) == 0:
								return []
				lowercase     ,	lowercase         =      min(__magic_name__						), max(__magic_name__						)
				lowercase         =      int(max_value - min_value						) + 1
				lowercase         =      [[] for _ in range(__magic_name__						)]

				for i in my_list:
								buckets[int(i - min_value						)].append(__magic_name__						)

				return [v for bucket in buckets for v in sorted(__magic_name__						)]


if __name__ == "__main__":
						from doctest import testmod

						testmod()
						assert bucket_sort([4, 5, 3, 2, 1]) == [1, 2, 3, 4, 5]
						assert bucket_sort([0, 1, -10, 15, 2, -2]) == [-10, -2, 0, 1, 2, 15]
