






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 __lowerCamelCase :





	"""simple docstring"""






	def __init__(							self       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    ):
							"""simple docstring"""







							_UpperCAmelCase									=			claim_vector
							_UpperCAmelCase									=			allocated_resources_table
							_UpperCAmelCase									=			maximum_claim_table

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							return [
							    sum(p_item[i] for p_item in self.__allocated_resources_table    )
							    for i in range(len(self.__allocated_resources_table[0]    )    )
							]

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							return np.array(self.__claim_vector    ) - np.array(
							    self.__processes_resource_summation()    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							return [
							    list(np.array(self.__maximum_claim_table[i]    ) - np.array(UpperCAmelCase    )    )
							    for i, allocated_resource in enumerate(self.__allocated_resources_table    )
							]

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							return {self.__need().index(UpperCAmelCase    ): i for i in self.__need()}

	def        UpperCamelCase    (							self       ,    **UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			self.__need()
							_UpperCAmelCase									=			self.__allocated_resources_table
							_UpperCAmelCase									=			self.__available_resources()
							_UpperCAmelCase									=			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:
													_UpperCAmelCase									=			False
													for each_need in need_list:
																			_UpperCAmelCase									=			True
																			for index, need in enumerate(UpperCAmelCase    ):
																									if need > available_resources[index]:
																															_UpperCAmelCase									=			False
																															break
																			if execution:
																									_UpperCAmelCase									=			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:
																																					_UpperCAmelCase									=			original_need_index
																									print(F"""Process {process_number + 1} is executing."""    )
																									# remove the process run from stack
																									need_list.remove(UpperCAmelCase    )
																									# update available/freed resources stack
																									_UpperCAmelCase									=			np.array(UpperCAmelCase    ) + np.array(
																									    alloc_resources_table[process_number]    )
																									print(
																									    'Updated available resource stack for processes: '
																									    + ' '.join([str(UpperCAmelCase    ) 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        UpperCamelCase    (							self    ):
							"""simple docstring"""







							print(' ' * 9 + 'Allocated Resource Table'    )
							for item in self.__allocated_resources_table:
													print(
													    F"""P{self.__allocated_resources_table.index(UpperCAmelCase    ) + 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(UpperCAmelCase    ) + 1}"""
													    + ' '.join(F"""{it:>8}""" for it in item    )
													    + '\n'    )
							print(
							    'Current Usage by Active Processes: '
							    + ' '.join(str(UpperCAmelCase    ) for x in self.__claim_vector    )    )
							print(
							    'Initial Available Resources:       '
							    + ' '.join(str(UpperCAmelCase    ) for x in self.__available_resources()    )    )
							time.sleep(1    )


if __name__ == "__main__":
		import doctest

		doctest.testmod()








def __A    (      __lowerCAmelCase	)->  list:





						"""simple docstring"""



						if len(__lowerCAmelCase	) < 2:
												return collection

						def circle_sort_util(__lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	) -> bool:
												_UpperCAmelCase									=			False

												if low == high:
																		return swapped

												_UpperCAmelCase									=			low
												_UpperCAmelCase									=			high

												while left < right:
																		if collection[left] > collection[right]:
																								_UpperCAmelCase					, _UpperCAmelCase									=			(
																								    collection[right],
																								    collection[left],
																								)
																								_UpperCAmelCase									=			True

																		left += 1
																		right -= 1

												if left == right and collection[left] > collection[right + 1]:
																		_UpperCAmelCase					, _UpperCAmelCase									=			(
																		    collection[right + 1],
																		    collection[left],
																		)

																		_UpperCAmelCase									=			True

												_UpperCAmelCase									=			low + int((high - low) / 2	)
												_UpperCAmelCase									=			circle_sort_util(__lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	)
												_UpperCAmelCase									=			circle_sort_util(__lowerCAmelCase ,		mid + 1 ,		__lowerCAmelCase	)

												return swapped or left_swap or right_swap

						_UpperCAmelCase									=			True

						while is_not_sorted is True:
												_UpperCAmelCase									=			circle_sort_util(__lowerCAmelCase ,		0 ,		len(__lowerCAmelCase	) - 1	)

						return collection


if __name__ == "__main__":
		_a      	=  input('''Enter numbers separated by a comma:\n''').strip()
		_a      	=  [int(item) for item in user_input.split(''',''')]
		print(circle_sort(unsorted))
