from collections import defaultdict


class      lowerCamelCase_					:






				'''simple docstring'''






				def __init__(     self			,			__lowercase			,			__lowercase)	->     Optional[Any]:
								__UpperCamelCase					:List[str]        =		total  # total no of tasks (N)

								# DP table will have a dimension of (2^M)*N
								# initially all values are set to -1
								__UpperCamelCase					:Union[str, Any]        =		[
								    [-1 for i in range(total + 1)] for j in range(2 ** len(__lowercase))
								]

								__UpperCamelCase					:int        =		defaultdict(__lowercase)  # 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					:Dict        =		(1 << len(__lowercase)) - 1







				def       UpperCamelCase__       (     self			,			__lowercase			,			__lowercase)	->     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
								__UpperCamelCase					:Tuple        =		self.count_ways_until(__lowercase			,			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					:Any        =		total_ways_util

								return self.dp[mask][task_no]







				def       UpperCamelCase__       (     self			,			__lowercase)	->     Tuple:
								# Store the list of persons for each task
								for i in range(len(__lowercase)):
												for j in task_performed[i]:
																self.task[j].append(__lowercase)

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

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






from ...utils import is_note_seq_available, is_transformers_available, is_torch_available
from ...utils import OptionalDependencyNotAvailable


try:
    if not (is_transformers_available() and is_torch_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_torch_and_transformers_objects import *  # noqa F403
else:
    from .notes_encoder import SpectrogramNotesEncoder
    from .continous_encoder import SpectrogramContEncoder
    from .pipeline_spectrogram_diffusion import (
        SpectrogramContEncoder,
        SpectrogramDiffusionPipeline,
        TaFilmDecoder,
    )

try:
    if not (is_transformers_available() and is_torch_available() and is_note_seq_available()):
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    from ...utils.dummy_transformers_and_torch_and_note_seq_objects import *  # noqa F403
else:
    from .midi_utils import MidiProcessor





