

from collections import defaultdict

class     __snake_case    :
       """simple docstring"""







       def __init__(		self      , _UpperCamelCase      , _UpperCamelCase   )      ->							Tuple:






              """simple docstring"""


              __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(_UpperCamelCase   )   )
              ]

              __snake_case       	=							defaultdict(_UpperCamelCase   )  # 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(_UpperCamelCase   )) - 1


       def 			a		(		self      , _UpperCamelCase      , _UpperCamelCase   )      ->							int:






              """simple docstring"""


              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(_UpperCamelCase      , 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 			a		(		self      , _UpperCamelCase   )      ->							Optional[Any]:






              """simple docstring"""


              for i in range(len(_UpperCamelCase   )   ):
                     for j in task_performed[i]:
                            self.task[j].append(_UpperCamelCase   )

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

    # the list of tasks that can be done by M persons.
    UpperCamelCase__		 =     [[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_tf_available,
    is_torch_available,
    is_vision_available,
)


UpperCamelCase__		 =     {
    '''configuration_convnext''': ['''CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''ConvNextConfig''', '''ConvNextOnnxConfig''']
}

try:
    if not is_vision_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		 =     ['''ConvNextFeatureExtractor''']
    UpperCamelCase__		 =     ['''ConvNextImageProcessor''']

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		 =     [
        '''CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST''',
        '''ConvNextForImageClassification''',
        '''ConvNextModel''',
        '''ConvNextPreTrainedModel''',
        '''ConvNextBackbone''',
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    UpperCamelCase__		 =     [
        '''TFConvNextForImageClassification''',
        '''TFConvNextModel''',
        '''TFConvNextPreTrainedModel''',
    ]

if TYPE_CHECKING:
    from .configuration_convnext import CONVNEXT_PRETRAINED_CONFIG_ARCHIVE_MAP, ConvNextConfig, ConvNextOnnxConfig

    try:
        if not is_vision_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .feature_extraction_convnext import ConvNextFeatureExtractor
        from .image_processing_convnext import ConvNextImageProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_convnext import (
            CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST,
            ConvNextBackbone,
            ConvNextForImageClassification,
            ConvNextModel,
            ConvNextPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_convnext import TFConvNextForImageClassification, TFConvNextModel, TFConvNextPreTrainedModel


else:
    import sys

    UpperCamelCase__		 =     _LazyModule(__name__, globals()['''__file__'''], _import_structure)

