






from collections import defaultdict
class       _UpperCAmelCase					:

				"""simple docstring"""




				def __init__(     self						:    List[Any],  lowerCamelCase						:    List[str],  lowerCamelCase						:    Optional[int]  ):

								'''simple docstring'''
								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(lowerCamelCase  )  )
								]

								lowercase__    =			defaultdict(lowerCamelCase  )  # 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(lowerCamelCase  )) - 1




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    Dict,  lowerCamelCase						:    Optional[int]  ):

								'''simple docstring'''
								# 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(lowerCamelCase,  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 				lowercase__   (     self						:    Tuple,  lowerCamelCase						:    List[Any]  ):

								'''simple docstring'''
								# Store the list of persons for each task
								for i in range(len(lowerCamelCase  )  ):
												for j in task_performed[i]:
																self.task[j].append(lowerCamelCase  )

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

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












from .configuration_bert_masked import MaskedBertConfig
from .modeling_bert_masked import (
    MaskedBertForMultipleChoice,
    MaskedBertForQuestionAnswering,
    MaskedBertForSequenceClassification,
    MaskedBertForTokenClassification,
    MaskedBertModel,
)
from .modules import *




