
from collections import defaultdict







class     lowercase		:




							def __init__(    self       ,A__       ,A__):
												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(A__))
												]

												lowercase						     =						defaultdict(A__)  # 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(A__)) - 1




							def 			A__				(    self       ,A__       ,A__):
												# 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
												lowercase						     =						self.count_ways_until(A__       ,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 			A__				(    self       ,A__):
												# Store the list of persons for each task
												for i in range(len(A__)):
																	for j in task_performed[i]:
																						self.task[j].append(A__)

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

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






lowercase__		:List[str]			  =   6_5521



def 	UpperCamelCase   (							lowerCAmelCase__		):
					'''simple docstring'''
					lowercase						     =						1
					lowercase						     =						0
					for plain_chr in plain_text:
										lowercase						     =						(a + ord(lowerCAmelCase__		)) % MOD_ADLER
										lowercase						     =						(b + a) % MOD_ADLER
					return (b << 16) | a




