
from __future__ import annotations

import time

import numpy as np

__A				=[8, 5, 9, 7]
__A				=[
    [2, 0, 1, 1],
    [0, 1, 2, 1],
    [4, 0, 0, 3],
    [0, 2, 1, 0],
    [1, 0, 3, 0],
]
__A				=[
    [3, 2, 1, 4],
    [0, 2, 5, 2],
    [5, 1, 0, 5],
    [1, 5, 3, 0],
    [3, 0, 3, 3],
]




class     _SCREAMING_SNAKE_CASE     :



	def __init__(    self						,  lowercase						,  lowercase						,  lowercase						,  )				->       None:
					lowerCamelCase_						=			claim_vector
					lowerCamelCase_						=			allocated_resources_table
					lowerCamelCase_						=			maximum_claim_table



	def     SCREAMING_SNAKE_CASE_(    self )				->       list[int]:
					return [
					    sum(p_item[i] for p_item in self.__allocated_resources_table )
					    for i in range(len(self.__allocated_resources_table[0] ) )
					]



	def     SCREAMING_SNAKE_CASE_(    self )				->       list[int]:
					return np.array(self.__claim_vector ) - np.array(
					    self.__processes_resource_summation() )



	def     SCREAMING_SNAKE_CASE_(    self )				->       list[list[int]]:
					return [
					    list(np.array(self.__maximum_claim_table[i] ) - np.array(lowercase ) )
					    for i, allocated_resource in enumerate(self.__allocated_resources_table )
					]



	def     SCREAMING_SNAKE_CASE_(    self )				->       dict[int, list[int]]:
					return {self.__need().index(lowercase ): i for i in self.__need()}



	def     SCREAMING_SNAKE_CASE_(    self						,  **lowercase )				->       None:
					lowerCamelCase_						=			self.__need()
					lowerCamelCase_						=			self.__allocated_resources_table
					lowerCamelCase_						=			self.__available_resources()
					lowerCamelCase_						=			self.__need_index_manager()
					for kw, val in kwargs.items():
									if kw and val is True:
													self.__pretty_data()
					print("_" * 50 + "\n" )
					while need_list:
									lowerCamelCase_						=			False
									for each_need in need_list:
													lowerCamelCase_						=			True
													for index, need in enumerate(lowercase ):
																	if need > available_resources[index]:
																					lowerCamelCase_						=			False
																					break
													if execution:
																	lowerCamelCase_						=			True
																	# get the original index of the process from ind_ctrl db
																	for original_need_index, need_clone in need_index_manager.items():
																					if each_need == need_clone:
																									lowerCamelCase_						=			original_need_index
																	print(f'Process {process_number + 1} is executing.' )
																	# remove the process run from stack
																	need_list.remove(lowercase )
																	# update available/freed resources stack
																	lowerCamelCase_						=			np.array(lowercase ) + np.array(
																	    alloc_resources_table[process_number] )
																	print(
																	    "Updated available resource stack for processes: "
																	    + " ".join([str(lowercase ) for x in available_resources] ) )
																	break
									if safe:
													print("The process is in a safe state.\n" )
									else:
													print("System in unsafe state. Aborting...\n" )
													break



	def     SCREAMING_SNAKE_CASE_(    self )				->       int:
					print(" " * 9 + "Allocated Resource Table" )
					for item in self.__allocated_resources_table:
									print(
									    f'P{self.__allocated_resources_table.index(lowercase ) + 1}'
									    + " ".join(f'{it:>8}' for it in item )
									    + "\n" )
					print(" " * 9 + "System Resource Table" )
					for item in self.__maximum_claim_table:
									print(
									    f'P{self.__maximum_claim_table.index(lowercase ) + 1}'
									    + " ".join(f'{it:>8}' for it in item )
									    + "\n" )
					print(
					    "Current Usage by Active Processes: "
					    + " ".join(str(lowercase ) for x in self.__claim_vector ) )
					print(
					    "Initial Available Resources:       "
					    + " ".join(str(lowercase ) for x in self.__available_resources() ) )
					time.sleep(1 )


if __name__ == "__main__":
			import doctest

			doctest.testmod()





"""simple docstring"""


def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       Optional[Any]          =			1
		for i in range(1					, num + 1 ):
				fact *= i
		return fact






def     a__    (    __SCREAMING_SNAKE_CASE )	->	int:
		__lowerCAmelCase:       List[str]          =			0
		while number > 0:
				__lowerCAmelCase:       Any          =			number % 1_0
				sum_of_digits += last_digit
				__lowerCAmelCase:       List[Any]          =			number // 1_0  # Removing the last_digit from the given number
		return sum_of_digits






def     a__    (    __SCREAMING_SNAKE_CASE = 1_0_0 )	->	int:
		__lowerCAmelCase:       Tuple          =			factorial(__SCREAMING_SNAKE_CASE )
		__lowerCAmelCase:       Optional[int]          =			split_and_add(__SCREAMING_SNAKE_CASE )
		return result


if __name__ == "__main__":
			print(solution(int(input("Enter the Number: ").strip())))


