






"""simple docstring"""







from collections import defaultdict


class      UpperCamelCase		:






						def __init__(		self  :List[str]			, __magic_name__  :Any			, __magic_name__  :List[Any]				)      ->List[Any]:
										lowercase    :      str       = total  # total no of tasks (N)

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

										lowercase    :      Union[str, Any]       = defaultdict(SCREAMING_SNAKE_CASE__				)  # 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
										lowercase    :      Tuple       = (1 << len(SCREAMING_SNAKE_CASE__				)) - 1






						def      __snake_case      (		self  :List[Any]			, __magic_name__  :int			, __magic_name__  :Optional[int]				)      ->Union[str, Any]:



										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
										lowercase    :      Optional[Any]       = self.count_ways_until(SCREAMING_SNAKE_CASE__			, 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.
										lowercase    :      Optional[int]       = total_ways_util

										return self.dp[mask][task_no]






						def      __snake_case      (		self  :List[str]			, __magic_name__  :int				)      ->int:



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

        # 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__":
				_lowerCAmelCase            =	5  # total no of tasks (the value of N)

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


from decimal import Decimal, getcontext
from math import ceil, factorial

def  __lowerCamelCase					( _lowercase			)       ->      str:

     if not isinstance(_lowercase						,     _lowercase			):
          raise TypeError('Undefined for non-integers'			)
     elif precision < 1:
          raise ValueError('Undefined for non-natural numbers'			)

     UpperCamelCase						    =					precision
     UpperCamelCase						    =					ceil(precision / 14			)
     UpperCamelCase						    =					426880 * Decimal(10005			).sqrt()
     UpperCamelCase						    =					1
     UpperCamelCase						    =					13591409
     UpperCamelCase						    =					Decimal(_lowercase			)
     for k in range(1						,     _lowercase			):
          UpperCamelCase						    =					factorial(6 * k			) // (factorial(3 * k			) * factorial(_lowercase			) ** 3)
          linear_term += 545140134
          exponential_term *= -262537412640768000
          partial_sum += Decimal(multinomial_term * linear_term			) / exponential_term
     return str(constant_term / partial_sum			)[:-1]


if __name__ == "__main__":
 _snake_case      = 50
 print(F"The first {n} digits of pi is: {pi(n)}")


