



'''simple docstring'''

from collections import defaultdict






class 						a_		:


							def __init__(				self   :						List[str]      ,						a_   :						Union[str, Any]      ,						a_   :						Union[str, Any]			)			->					str:
										snake_case:    Any      							=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:    Union[str, Any]      							=[
										    [-1 for i in range(total + 1			)] for j in range(2 ** len(A_			)			)
										]

										snake_case:    Optional[int]      							=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
										snake_case:    List[str]      							=(1 << len(A_			)) - 1


							def    UpperCamelCase     (				self   :						Optional[int]      ,						a_   :						Union[str, Any]      ,						a_   :						Union[str, Any]			)			->					int:
										# 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
										snake_case:    Optional[Any]      							=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.
										snake_case:    Union[str, Any]      							=total_ways_util

										return self.dp[mask][task_no]




							def    UpperCamelCase     (				self   :						List[Any]      ,						a_   :						List[Any]			)			->					int:
										# 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__":
	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"""




import json
import os
import tempfile

from transformers.testing_utils import check_json_file_has_correct_format




class 			__snake_case   :
							__a					 =       None




							def   __a   (     self:    int   ):
										__lowerCamelCase          =      self.feature_extraction_class(**self.feat_extract_dict   )
										__lowerCamelCase          =      json.loads(feat_extract.to_json_string()   )
										for key, value in self.feat_extract_dict.items():
													self.assertEqual(obj[key]     ,							A_   )




							def   __a   (     self:    List[str]   ):
										__lowerCamelCase          =      self.feature_extraction_class(**self.feat_extract_dict   )

										with tempfile.TemporaryDirectory() as tmpdirname:
													__lowerCamelCase          =      os.path.join(A_     ,							"""feat_extract.json"""   )
													feat_extract_first.to_json_file(A_   )
													__lowerCamelCase          =      self.feature_extraction_class.from_json_file(A_   )

										self.assertEqual(feat_extract_second.to_dict()     ,							feat_extract_first.to_dict()   )




							def   __a   (     self:    Optional[Any]   ):
										__lowerCamelCase          =      self.feature_extraction_class(**self.feat_extract_dict   )

										with tempfile.TemporaryDirectory() as tmpdirname:
													__lowerCamelCase          =      feat_extract_first.save_pretrained(A_   )[0]
													check_json_file_has_correct_format(A_   )
													__lowerCamelCase          =      self.feature_extraction_class.from_pretrained(A_   )

										self.assertEqual(feat_extract_second.to_dict()     ,							feat_extract_first.to_dict()   )




							def   __a   (     self:    List[Any]   ):
										__lowerCamelCase          =      self.feature_extraction_class()
										self.assertIsNotNone(A_   )




