


from __future__ import annotations

import time

import numpy as np

snake_case				:    Any       				=     [8, 5, 9, 7]
snake_case				:    Optional[Any]       				=     [
    [2, 0, 1, 1],
    [0, 1, 2, 1],
    [4, 0, 0, 3],
    [0, 2, 1, 0],
    [1, 0, 3, 0],
]
snake_case				:    List[Any]       				=     [
    [3, 2, 1, 4],
    [0, 2, 5, 2],
    [5, 1, 0, 5],
    [1, 5, 3, 0],
    [3, 0, 3, 3],
]







class 		_snake_case  :




 def __init__(		self					,  _lowerCamelCase					,  _lowerCamelCase					,  _lowerCamelCase					,  ):
       a						:List[Any] 							=       claim_vector
       a						:List[str] 							=       allocated_resources_table
       a						:Any 							=       maximum_claim_table




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       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    ):
       return np.array(self.__claim_vector    ) - np.array(
           self.__processes_resource_summation()    )




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       return [
           list(np.array(self.__maximum_claim_table[i]    ) - np.array(_lowerCamelCase    )    )
           for i, allocated_resource in enumerate(self.__allocated_resources_table    )
       ]




 def        SCREAMING_SNAKE_CASE__				(		self    ):
       return {self.__need().index(_lowerCamelCase    ): i for i in self.__need()}




 def        SCREAMING_SNAKE_CASE__				(		self					,  **_lowerCamelCase    ):
       a						:Tuple 							=       self.__need()
       a						:int 							=       self.__allocated_resources_table
       a						:Dict 							=       self.__available_resources()
       a						:str 							=       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:
             a						:Optional[Any] 							=       False
             for each_need in need_list:
                   a						:int 							=       True
                   for index, need in enumerate(_lowerCamelCase    ):
                         if need > available_resources[index]:
                               a						:List[Any] 							=       False
                               break
                   if execution:
                         a						:Dict 							=       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:
                                     a						:int 							=       original_need_index
                         print(F'''Process {process_number + 1} is executing.'''    )
                         # remove the process run from stack
                         need_list.remove(_lowerCamelCase    )
                         # update available/freed resources stack
                         a						:List[Any] 							=       np.array(_lowerCamelCase    ) + np.array(
                             alloc_resources_table[process_number]    )
                         print(
                             '''Updated available resource stack for processes: '''
                             + ''' '''.join([str(_lowerCamelCase    ) 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    ):
       print(''' ''' * 9 + '''Allocated Resource Table'''    )
       for item in self.__allocated_resources_table:
             print(
                 F'''P{self.__allocated_resources_table.index(_lowerCamelCase    ) + 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(_lowerCamelCase    ) + 1}'''
                 + ''' '''.join(F'''{it:>8}''' for it in item    )
                 + '''\n'''    )
       print(
           '''Current Usage by Active Processes: '''
           + ''' '''.join(str(_lowerCamelCase    ) for x in self.__claim_vector    )    )
       print(
           '''Initial Available Resources:       '''
           + ''' '''.join(str(_lowerCamelCase    ) for x in self.__available_resources()    )    )
       time.sleep(1    )


if __name__ == "__main__":
     import doctest

     doctest.testmod()









def 				__lowerCamelCase						( UpperCAmelCase_						:		int = 1000						):




      """simple docstring"""





      a							,				a						:int 							=       1, 1
      a						:Any 							=       2
      while True:
            a						:Optional[int] 							=       0
            a						:str 							=       fa + fa
            a							,				a						:List[Any] 							=       fa, f
            index += 1
            for _ in str(UpperCAmelCase_						):
                  i += 1
            if i == n:
                  break
      return index


if __name__ == "__main__":
     print(solution(int(str(input()).strip())))





