"""simple docstring"""



from collections import defaultdict



class      _A	:




    """simple docstring"""




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

         __snake_case				=							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				=							(1 << len(A_    )) - 1
    def  lowercase					(		self							:     List[str]	,      A_							:     Optional[int]	,      A_							:     Optional[int]    )    ->       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
         __snake_case				=							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				=							total_ways_util

         return self.dp[mask][task_no]







    def  lowercase					(		self							:     int	,      A_							:     Optional[Any]    )    ->       List[str]:
         # 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		:		Optional[Any]														=							5  # total no of tasks (the value of N)

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



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


__lowercase		:		Optional[Any]														=							{
    "configuration_falcon": ["FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP", "FalconConfig"],
}

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowercase		:		str														=							[
           "FALCON_PRETRAINED_MODEL_ARCHIVE_LIST",
           "FalconForCausalLM",
           "FalconModel",
           "FalconPreTrainedModel",
           "FalconForSequenceClassification",
           "FalconForTokenClassification",
           "FalconForQuestionAnswering",
       ]


if TYPE_CHECKING:
       from .configuration_falcon import FALCON_PRETRAINED_CONFIG_ARCHIVE_MAP, FalconConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_falcon import (
                  FALCON_PRETRAINED_MODEL_ARCHIVE_LIST,
                  FalconForCausalLM,
                  FalconForQuestionAnswering,
                  FalconForSequenceClassification,
                  FalconForTokenClassification,
                  FalconModel,
                  FalconPreTrainedModel,
              )


else:
       import sys

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