



"""simple docstring"""





from collections import defaultdict




class 			lowercase__			:
							'''simple docstring'''







							def __init__(  self	,       snake_case	,       snake_case						)			->							Optional[Any]:
									_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(snake_case						)						)
									]

									_UpperCAmelCase							 =		defaultdict(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(snake_case						)) - 1






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Dict:
									# 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
									_UpperCAmelCase							 =		self.count_ways_until(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        lowerCamelCase_   (  self	,       snake_case						)			->							List[str]:
									# Store the list of persons for each task
									for i in range(len(snake_case						)						):
											for j in task_performed[i]:
													self.task[j].append(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__":
	lowercase  							=					5  # total no of tasks (the value of N)

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







"""simple docstring"""





from __future__ import annotations




def 	UpperCAmelCase     (		A	:						int     ,				A	:						int       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		[]
		create_all_state(1     ,				A     ,				A     ,				[]     ,				A       )
		return result




def 	UpperCAmelCase     (		A	:						int     ,				A	:						int     ,				A	:						int     ,				A	:						list[int]     ,				A	:						list[list[int]]     ,				):

		'''simple docstring'''


		if level == 0:
				total_list.append(current_list[:]       )
				return

		for i in range(A     ,				total_number - level + 2       ):
				current_list.append(A       )
				create_all_state(i + 1     ,				A     ,				level - 1     ,				A     ,				A       )
				current_list.pop()




def 	UpperCAmelCase     (		A	:						list[list[int]]       ):

		'''simple docstring'''


		for i in total_list:
				print(*A       )


if __name__ == "__main__":
					lowercase  							=					4
					lowercase  							=					2
					lowercase  							=					generate_all_combinations(n, k)
					print_all_state(total_list)


