

from collections import defaultdict

class 						__UpperCamelCase    :




 def __init__(		self	:						Optional[Any]		,	lowerCAmelCase	:						Optional[Any]		,	lowerCAmelCase	:						Dict							):


  '''simple docstring'''







  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(lowerCAmelCase							)							)
  ]

  UpperCAmelCase_       				=			defaultdict(lowerCAmelCase							)  # 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(lowerCAmelCase							)) - 1




 def       __A					(		self	:						Union[str, Any]		,	lowerCAmelCase	:						List[Any]		,	lowerCAmelCase	:						Dict							):


  '''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
  UpperCAmelCase_       				=			self.count_ways_until(lowerCAmelCase		,	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       __A					(		self	:						Optional[Any]		,	lowerCAmelCase	:						List[str]							):


  '''simple docstring'''







  for i in range(len(lowerCAmelCase							)							):
   for j in task_performed[i]:
    self.task[j].append(lowerCAmelCase							)

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

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


from collections.abc import Sequence



def       __lowerCAmelCase      (						A       ,     A = False    ):
	if not arr:
		return 0

	UpperCAmelCase_       				=			0 if allow_empty_subarrays else float("-inf"    )
	UpperCAmelCase_       				=			0.0
	for num in arr:
		UpperCAmelCase_       				=			max(0 if allow_empty_subarrays else num       ,     curr_sum + num    )
		UpperCAmelCase_       				=			max(A       ,     A    )

	return max_sum


if __name__ == "__main__":
				from doctest import testmod

				testmod()

				_a:    Any 							=			[-2, 1, -3, 4, -1, 2, 1, -5, 4]
				print(F'{max_subarray_sum(nums) = }')