'''simple docstring'''




from collections import defaultdict

class 	_lowercase:



   """simple docstring"""





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

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








'''simple docstring'''





def 			a_	(				_lowerCAmelCase			,_lowerCAmelCase			) -> tuple[float, float]:

  # Check if the input is valid
  if not len(_lowerCAmelCase			) == len(_lowerCAmelCase			) == 3:
    raise ValueError('Please enter a valid equation.'			)
  if equationa[0] == equationa[1] == equationa[0] == equationa[1] == 0:
    raise ValueError('Both a & b of two equations can\'t be zero.'			)

  # Extract the coefficients
  __lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			:			Union[str, Any]       			=					equationa
  __lowerCamelCase			,__lowerCamelCase			,__lowerCamelCase			:			Any       			=					equationa

  # Calculate the determinants of the matrices
  __lowerCamelCase			:			Union[str, Any]       			=					aa * ba - aa * ba
  __lowerCamelCase			:			Dict       			=					ca * ba - ca * ba
  __lowerCamelCase			:			List[str]       			=					aa * ca - aa * ca

  # Check if the system of linear equations has a solution (using Cramer's rule)
  if determinant == 0:
    if determinant_x == determinant_y == 0:
      raise ValueError('Infinite solutions. (Consistent system)'			)
    else:
      raise ValueError('No solution. (Inconsistent system)'			)
  else:
    if determinant_x == determinant_y == 0:
      # Trivial solution (Inconsistent system)
      return (0.0, 0.0)
    else:
      __lowerCamelCase			:			Tuple       			=					determinant_x / determinant
      __lowerCamelCase			:			Union[str, Any]       			=					determinant_y / determinant
      # Non-Trivial Solution (Consistent system)
      return (x, y)






