


'''simple docstring'''







from collections import defaultdict







class A__       :






      def __init__( self			:Optional[int]     ,						SCREAMING_SNAKE_CASE			:int     ,						SCREAMING_SNAKE_CASE			:Union[str, Any]	)       ->					int:




             '''simple docstring'''
             _a    : List[Any]     					=total  # total no of tasks (N)

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

             _a    : str     					=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
             _a    : Optional[int]     					=(1 << len(UpperCamelCase_	)) - 1






      def __UpperCAmelCase       ( self			:Optional[int]     ,						SCREAMING_SNAKE_CASE			:List[str]     ,						SCREAMING_SNAKE_CASE			:int	)       ->					Optional[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
             _a    : str     					=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.
             _a    : Optional[int]     					=total_ways_util

             return self.dp[mask][task_no]






      def __UpperCAmelCase       ( self			:str     ,						SCREAMING_SNAKE_CASE			:int	)       ->					List[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__":
   A__:    Optional[int]					    =       5  # total no of tasks (the value of N)

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






'''simple docstring'''
import re

from filelock import FileLock


try:
		import nltk

		__snake_case							      =     True
except (ImportError, ModuleNotFoundError):
		__snake_case							      =     False

if NLTK_AVAILABLE:
		with FileLock('''.lock''') as lock:
				nltk.download('''punkt''', quiet=True)


def 			a      (			__a   )  ->	str:



					'''simple docstring'''






					re.sub('''<n>''' ,					'''''' ,					__a   )  # remove pegasus newline char
					assert NLTK_AVAILABLE, "nltk must be installed to separate newlines between sentences. (pip install nltk)"
					return "\n".join(nltk.sent_tokenize(__a   )   )