


from collections import defaultdict






class      UpperCamelCase:


					def __init__(    self						:		Optional[Any]  ,     SCREAMING_SNAKE_CASE						:		int  ,     SCREAMING_SNAKE_CASE						:		int    )      ->						Optional[int]:




											'''simple docstring'''

											__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
											__snake_case				=		[
											    [-1 for i in range(total + 1    )] for j in range(2 ** len(SCREAMING_SNAKE_CASE    )    )
											]

											__snake_case				=		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
											__snake_case				=		(1 << len(SCREAMING_SNAKE_CASE    )) - 1


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

											return self.dp[mask][task_no]






					def 				SCREAMING_SNAKE_CASE_	(    self						:		int  ,     SCREAMING_SNAKE_CASE						:		Optional[Any]    )      ->						List[str]:




											'''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__":
	A				:       List[str]      =  5  # total no of tasks (the value of N)

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









def 						_lowerCAmelCase							(     _lowerCAmelCase = 100			)    ->						int:


						'''simple docstring'''






						__snake_case				=		n * (n + 1) * (2 * n + 1) / 6
						__snake_case				=		(n * (n + 1) / 2) ** 2
						return int(square_of_sum - sum_of_squares			)


if __name__ == "__main__":
	print(f'''{solution() = }''')





