
from collections import defaultdict

class        _UpperCamelCase				:






			'''simple docstring'''

			def __init__(       self :       List[str]						,	snake_case_ :       Optional[Any]						,	snake_case_ :       List[str]      ):
							UpperCamelCase_:							Optional[Any]	=						total  # total no of tasks (N)

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

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

			def       lowerCAmelCase__	(       self :       Union[str, Any]						,	snake_case_ :       int						,	snake_case_ :       Any      ):
							# 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_:							List[str]	=						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_:							Union[str, Any]	=						total_ways_util

							return self.dp[mask][task_no]




			def       lowerCAmelCase__	(       self :       Optional[Any]						,	snake_case_ :       Union[str, Any]      ):
							# 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__":
							lowerCamelCase_						: int         =  5  # total no of tasks (the value of N)

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








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCamelCase_						: Optional[Any]         =  {
    """configuration_distilbert""": [
        """DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """DistilBertConfig""",
        """DistilBertOnnxConfig""",
    ],
    """tokenization_distilbert""": ["""DistilBertTokenizer"""],
}

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: List[Any]         =  ["""DistilBertTokenizerFast"""]

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: Optional[int]         =  [
							    """DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """DistilBertForMaskedLM""",
							    """DistilBertForMultipleChoice""",
							    """DistilBertForQuestionAnswering""",
							    """DistilBertForSequenceClassification""",
							    """DistilBertForTokenClassification""",
							    """DistilBertModel""",
							    """DistilBertPreTrainedModel""",
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: List[str]         =  [
							    """TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """TFDistilBertForMaskedLM""",
							    """TFDistilBertForMultipleChoice""",
							    """TFDistilBertForQuestionAnswering""",
							    """TFDistilBertForSequenceClassification""",
							    """TFDistilBertForTokenClassification""",
							    """TFDistilBertMainLayer""",
							    """TFDistilBertModel""",
							    """TFDistilBertPreTrainedModel""",
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowerCamelCase_						: Dict         =  [
							    """FlaxDistilBertForMaskedLM""",
							    """FlaxDistilBertForMultipleChoice""",
							    """FlaxDistilBertForQuestionAnswering""",
							    """FlaxDistilBertForSequenceClassification""",
							    """FlaxDistilBertForTokenClassification""",
							    """FlaxDistilBertModel""",
							    """FlaxDistilBertPreTrainedModel""",
							]


if TYPE_CHECKING:
							from .configuration_distilbert import (
							    DISTILBERT_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    DistilBertConfig,
							    DistilBertOnnxConfig,
							)
							from .tokenization_distilbert import DistilBertTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_distilbert_fast import DistilBertTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_distilbert import (
														    DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    DistilBertForMaskedLM,
														    DistilBertForMultipleChoice,
														    DistilBertForQuestionAnswering,
														    DistilBertForSequenceClassification,
														    DistilBertForTokenClassification,
														    DistilBertModel,
														    DistilBertPreTrainedModel,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_distilbert import (
														    TF_DISTILBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFDistilBertForMaskedLM,
														    TFDistilBertForMultipleChoice,
														    TFDistilBertForQuestionAnswering,
														    TFDistilBertForSequenceClassification,
														    TFDistilBertForTokenClassification,
														    TFDistilBertMainLayer,
														    TFDistilBertModel,
														    TFDistilBertPreTrainedModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_distilbert import (
														    FlaxDistilBertForMaskedLM,
														    FlaxDistilBertForMultipleChoice,
														    FlaxDistilBertForQuestionAnswering,
														    FlaxDistilBertForSequenceClassification,
														    FlaxDistilBertForTokenClassification,
														    FlaxDistilBertModel,
														    FlaxDistilBertPreTrainedModel,
														)

else:
							import sys

							lowerCamelCase_						: Optional[Any]         =  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)






