




from collections import defaultdict





class     SCREAMING_SNAKE_CASE__		:
     def __init__(						self	:		Tuple       ,						__lowerCamelCase	:		List[Any]       ,						__lowerCamelCase	:		Union[str, Any]						):



       """simple docstring"""
       lowerCAmelCase__										=      total  # total no of tasks (N)

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

       lowerCAmelCase__										=      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
       lowerCAmelCase__										=      (1 << len(A__						)) - 1
     def        A__      (						self	:		Any       ,						__lowerCamelCase	:		Optional[int]       ,						__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
       lowerCAmelCase__										=      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.
       lowerCAmelCase__										=      total_ways_util

       return self.dp[mask][task_no]



     def        A__      (						self	:		List[Any]       ,						__lowerCamelCase	:		int						):



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

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




import unittest

from transformers import load_tool
from transformers.utils import is_torch_available


if is_torch_available():
	import torch

from transformers.testing_utils import require_torch

from .test_tools_common import ToolTesterMixin



@require_torch
class        _a		(unittest.TestCase						,  __magic_name__							):


					'''simple docstring'''






					def     __A     (					self     ):
						A__				:       List[str]	  =						load_tool("""text-to-speech"""     )
						self.tool.setup()






					def     __A     (					self     ):
						# SpeechT5 isn't deterministic
						torch.manual_seed(0     )
						A__				:       Tuple	  =						self.tool("""hey"""     )
						A__				:       Tuple	  =						result.to_raw()
						self.assertTrue(
						    torch.allclose(
						        resulting_tensor[:3]       ,			torch.tensor([-0.0_0_0_5_9_6_6_6_6_8_8_3_2_1_1_5_8_2_9, -0.0_0_0_3_6_5_7_6_4_0_1_9_0_7_9_5_0_6_4, -0.0_0_0_1_3_4_3_9_5_0_2_7_9_9_8_8_3_4_8_5]     )       ,			)     )






					def     __A     (					self     ):
						# SpeechT5 isn't deterministic
						torch.manual_seed(0     )
						A__				:       Any	  =						self.tool("""hey"""     )
						A__				:       Optional[Any]	  =						result.to_raw()
						self.assertTrue(
						    torch.allclose(
						        resulting_tensor[:3]       ,			torch.tensor([-0.0_0_0_5_9_6_6_6_6_8_8_3_2_1_1_5_8_2_9, -0.0_0_0_3_6_5_7_6_4_0_1_9_0_7_9_5_0_6_4, -0.0_0_0_1_3_4_3_9_5_0_2_7_9_9_8_8_3_4_8_5]     )       ,			)     )



