





"""simple docstring"""






from collections import defaultdict




class 				__lowercase			:







					'''simple docstring'''




					def __init__(						self	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									__a :						str			       =  total  # total no of tasks (N)

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

									__a :						Tuple			       =  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
									__a :						Dict			       =  (1 << len(_UpperCAmelCase     )) - 1







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase	,			_UpperCAmelCase     ):
									# 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
									__a :						Optional[int]			       =  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.
									__a :						Optional[int]			       =  total_ways_util

									return self.dp[mask][task_no]







					def  _lowerCamelCase		(						self	,			_UpperCAmelCase     ):
									# Store the list of persons for each task
									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__":
				A 			=  5  # total no of tasks (the value of N)

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






"""simple docstring"""






def     __A      (			a_						:int   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float(moles / volume) * nfactor)

def     __A      (			a_						:float   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float((moles * 0.0_8_2_1 * temperature) / (volume)))

def     __A      (			a_						:float   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float((moles * 0.0_8_2_1 * temperature) / (pressure)))

def     __A      (			a_						:float   ,       a_						:float   ,       a_						:float)		->		float:
				return round(float((pressure * volume) / (0.0_8_2_1 * moles)))


if __name__ == "__main__":
		import doctest

		doctest.testmod()