


"""simple docstring"""




from collections import defaultdict




class 			__snake_case   :




							def __init__(     self:    List[str]     ,							A_:    Union[str, Any]     ,							A_:    Union[str, Any]   ):
										__lowerCamelCase          =      total  # total no of tasks (N)

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

										__lowerCamelCase          =      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
										__lowerCamelCase          =      (1 << len(A_   )) - 1




							def   __a   (     self:    Optional[int]     ,							A_:    Union[str, Any]     ,							A_:    Union[str, Any]   ):
										# 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
										__lowerCamelCase          =      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.
										__lowerCamelCase          =      total_ways_util

										return self.dp[mask][task_no]




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

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








"""simple docstring"""




from collections.abc import Callable





def       a_ (	lowercase__ :Callable[[float], float],			lowercase__ :float,			lowercase__ :float     ):
			__lowerCamelCase          =      a
			__lowerCamelCase          =      b
			if function(lowercase__     ) == 0:  # one of the a or b is a root for the function
						return a
			elif function(lowercase__     ) == 0:
						return b
			elif (
			    function(lowercase__     ) * function(lowercase__     ) > 0
			):  # if none of these are root and they are both positive or negative,
						# then this algorithm can't find the root
						raise ValueError("""could not find root in given interval."""     )
			else:
						__lowerCamelCase          =      start + (end - start) / 2.0
						while abs(start - mid     ) > 10**-7:  # until precisely equals to 10^-7
									if function(lowercase__     ) == 0:
												return mid
									elif function(lowercase__     ) * function(lowercase__     ) < 0:
												__lowerCamelCase          =      mid
									else:
												__lowerCamelCase          =      mid
									__lowerCamelCase          =      start + (end - start) / 2.0
						return mid





def       a_ (	lowercase__ :float     ):
			return x**3 - 2 * x - 5


if __name__ == "__main__":
					print(bisection(f, 1, 1_0_0_0))

					import doctest

					doctest.testmod()




