






'''simple docstring'''






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







   def __init__(self					,   __a					,   __a					,   __a					,   )			->      None:
      """simple docstring"""






      __snake_case				:      Dict     							= claim_vector
      __snake_case				:      str     							= allocated_resources_table
      __snake_case				:      Tuple     							= maximum_claim_table







   def     SCREAMING_SNAKE_CASE__					(self)			->      list[int]:
      """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     SCREAMING_SNAKE_CASE__					(self)			->      list[int]:
      """simple docstring"""






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







   def     SCREAMING_SNAKE_CASE__					(self)			->      list[list[int]]:
      """simple docstring"""






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







   def     SCREAMING_SNAKE_CASE__					(self)			->      dict[int, list[int]]:
      """simple docstring"""






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







   def     SCREAMING_SNAKE_CASE__					(self					,   **__a)			->      None:
      """simple docstring"""






      __snake_case				:      Optional[Any]     							= self.__need()
      __snake_case				:      List[Any]     							= self.__allocated_resources_table
      __snake_case				:      List[str]     							= self.__available_resources()
      __snake_case				:      Any     							= self.__need_index_manager()
      for kw, val in kwargs.items():
         if kw and val is True:
            self.__pretty_data()
      print('_' * 5_0 + '\n')
      while need_list:
         __snake_case				:      List[str]     							= False
         for each_need in need_list:
            __snake_case				:      int     							= True
            for index, need in enumerate(__a):
               if need > available_resources[index]:
                  __snake_case				:      Any     							= False
                  break
            if execution:
               __snake_case				:      Union[str, Any]     							= 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:
                     __snake_case				:      List[str]     							= original_need_index
               print(F"""Process {process_number + 1} is executing.""")
               # remove the process run from stack
               need_list.remove(__a)
               # update available/freed resources stack
               __snake_case				:      Union[str, Any]     							= np.array(__a) + np.array(
                   alloc_resources_table[process_number])
               print(
                   'Updated available resource stack for processes: '
                   + ' '.join([str(__a) 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)			->      Union[str, Any]:
      """simple docstring"""






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


if __name__ == "__main__":
      import doctest

      doctest.testmod()







'''simple docstring'''






def        _SCREAMING_SNAKE_CASE  (				A  :       list  )    -> list:







   """simple docstring"""
   __snake_case				:      Tuple     							= False
   while is_sorted is False:  # Until all the indices are traversed keep looping
      __snake_case				:      Optional[Any]     							= True
      for i in range(0  ,		len(A  ) - 1  ,		2  ):  # iterating over all even indices
         if input_list[i] > input_list[i + 1]:
            __snake_case							,__snake_case				:      int     							= input_list[i + 1], input_list[i]
            # swapping if elements not in order
            __snake_case				:      List[Any]     							= False

      for i in range(1  ,		len(A  ) - 1  ,		2  ):  # iterating over all odd indices
         if input_list[i] > input_list[i + 1]:
            __snake_case							,__snake_case				:      Tuple     							= input_list[i + 1], input_list[i]
            # swapping if elements not in order
            __snake_case				:      Any     							= False
   return input_list


if __name__ == "__main__":
      print('''Enter list to be sorted''')
      __A    	=   [int(x) for x in input().split()]
      # inputing elements of the list in one line
      __A    	=   odd_even_sort(input_list)
      print('''The sorted list is''')
      print(sorted_list)