





'''simple docstring'''


from collections import defaultdict






class     lowerCAmelCase__ :

       '''simple docstring'''

       def __init__( self					:				Tuple       ,     a__					:				Optional[int]       ,     a__					:				Union[str, Any]						):
              UpperCAmelCase  =						total  # total no of tasks (N)

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

              UpperCAmelCase  =						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
              UpperCAmelCase  =						(1 << len(a__						)) - 1

       def 			__snake_case      ( self					:				List[Any]       ,     a__					:				Union[str, Any]       ,     a__					:				List[str]						):
              # 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  =						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.
              UpperCAmelCase  =						total_ways_util

              return self.dp[mask][task_no]



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

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








'''simple docstring'''
from argparse import ArgumentParser

from .add_new_model import AddNewModelCommand
from .add_new_model_like import AddNewModelLikeCommand
from .convert import ConvertCommand
from .download import DownloadCommand
from .env import EnvironmentCommand
from .lfs import LfsCommands
from .pt_to_tf import PTtoTFCommand
from .run import RunCommand
from .serving import ServeCommand
from .user import UserCommands





def 			lowerCamelCase(							)		->		int:
			A_									= ArgumentParser('Transformers CLI tool'       ,usage='transformers-cli <command> [<args>]'     )
			A_									= parser.add_subparsers(help='transformers-cli command helpers'     )

			# Register commands
			ConvertCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			DownloadCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			EnvironmentCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			RunCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			ServeCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			UserCommands.register_subcommand(SCREAMING_SNAKE_CASE_     )
			AddNewModelCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			AddNewModelLikeCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )
			LfsCommands.register_subcommand(SCREAMING_SNAKE_CASE_     )
			PTtoTFCommand.register_subcommand(SCREAMING_SNAKE_CASE_     )

			# Let's go
			A_									= parser.parse_args()

			if not hasattr(SCREAMING_SNAKE_CASE_       ,'func'     ):
						parser.print_help()
						exit(1     )

			# Run
			A_									= args.func(SCREAMING_SNAKE_CASE_     )
			service.run()


if __name__ == "__main__":
							main()




