



from collections import defaultdict




class 							lowerCAmelCase__  :







					def __init__(       self      :     Tuple			,		_A      :     Dict			,		_A      :     Dict):
											A__	:							Dict						    = total  # total no of tasks (N)

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

											A__	:							Optional[int]						    = 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
											A__	:							Optional[Any]						    = (1 << len(_A)) - 1







					def  _lowercase			(       self      :     Optional[int]			,		_A      :     List[str]			,		_A      :     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
											A__	:							Tuple						    = 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.
											A__	:							Any						    = total_ways_util

											return self.dp[mask][task_no]







					def  _lowercase			(       self      :     Tuple			,		_A      :     List[Any]):
											# 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__":
		snake_case    :						Optional[int]  =						5  # total no of tasks (the value of N)

		# the list of tasks that can be done by M persons.
		snake_case    :						int  =						[[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 is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device


if is_torch_available():
		from transformers import AutoModelForSeqaSeqLM, AutoTokenizer




@require_torch
@require_sentencepiece
@require_tokenizers
class 							lowerCAmelCase__  (	unittest.TestCase						):







					@slow
					def  _lowercase			(       self      :     List[Any]):
											A__	:							Optional[int]						    = AutoModelForSeqaSeqLM.from_pretrained("google/mt5-small"			,		return_dict=_A).to(_A)
											A__	:							Any						    = AutoTokenizer.from_pretrained("google/mt5-small")

											A__	:							int						    = tokenizer("Hello there"			,		return_tensors="pt").input_ids
											A__	:							List[str]						    = tokenizer("Hi I am"			,		return_tensors="pt").input_ids

											A__	:							int						    = model(input_ids.to(_A)			,		labels=labels.to(_A)).loss
											A__	:							Optional[int]						    = -(labels.shape[-1] * loss.item())

											A__	:							List[str]						    = -84.91_27
											self.assertTrue(abs(mtf_score - EXPECTED_SCORE) < 1e-4)