


from collections import deque
from math import floor
from random import random
from time import time







class 			_lowercase :


       """simple docstring"""




       def __init__(   self							:			Tuple       ):


             '''simple docstring'''



             lowerCamelCase__		:				int    =  {}





       def 						lowerCAmelCase     (   self							:			str					,      __lowerCamelCase							:			Tuple					,      __lowerCamelCase							:			Optional[Any]					,      __lowerCamelCase							:			Any=1       ):


             '''simple docstring'''



             if self.graph.get(__lowerCAmelCase       ):
                   if self.graph[u].count([w, v]       ) == 0:
                         self.graph[u].append([w, v]       )
             else:
                   lowerCamelCase__		:				Optional[int]    =  [[w, v]]
             if not self.graph.get(__lowerCAmelCase       ):
                   lowerCamelCase__		:				List[Any]    =  []





       def 						lowerCAmelCase     (   self							:			Optional[Any]       ):


             '''simple docstring'''



             return list(self.graph       )





       def 						lowerCAmelCase     (   self							:			Dict					,      __lowerCamelCase							:			Union[str, Any]					,      __lowerCamelCase							:			Optional[Any]       ):


             '''simple docstring'''



             if self.graph.get(__lowerCAmelCase       ):
                   for _ in self.graph[u]:
                         if _[1] == v:
                               self.graph[u].remove(__lowerCAmelCase       )





       def 						lowerCAmelCase     (   self							:			List[Any]					,      __lowerCamelCase							:			int=-2					,      __lowerCamelCase							:			Tuple=-1       ):


             '''simple docstring'''



             if s == d:
                   return []
             lowerCamelCase__		:				str    =  []
             lowerCamelCase__		:				str    =  []
             if s == -2:
                   lowerCamelCase__		:				Union[str, Any]    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				List[Any]    =  s

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				Optional[Any]    =  s
                         for node in self.graph[s]:
                               if visited.count(node[1]       ) < 1:
                                     if node[1] == d:
                                           visited.append(__lowerCAmelCase       )
                                           return visited
                                     else:
                                           stack.append(node[1]       )
                                           visited.append(node[1]       )
                                           lowerCamelCase__		:				Dict    =  node[1]
                                           break

            # check if all the children are visited
                   if s == ss:
                         stack.pop()
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				List[str]    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				Optional[Any]    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return visited





       def 						lowerCAmelCase     (   self							:			List[str]					,      __lowerCamelCase							:			int=-1       ):


             '''simple docstring'''



             if c == -1:
                   lowerCamelCase__		:				int    =  floor(random() * 10000       ) + 10
             for i in range(__lowerCAmelCase       ):
                   # every vertex has max 100 edges
                   for _ in range(floor(random() * 102       ) + 1       ):
                         lowerCamelCase__		:				List[str]    =  floor(random() * c       ) + 1
                         if n != i:
                               self.add_pair(__lowerCAmelCase					,      __lowerCAmelCase					,      1       )





       def 						lowerCAmelCase     (   self							:			List[Any]					,      __lowerCamelCase							:			int=-2       ):


             '''simple docstring'''



             lowerCamelCase__		:				str    =  deque()
             lowerCamelCase__		:				Optional[int]    =  []
             if s == -2:
                   lowerCamelCase__		:				str    =  list(self.graph       )[0]
             d.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             while d:
                   lowerCamelCase__		:				Union[str, Any]    =  d.popleft()
                   if len(self.graph[s]       ) != 0:
                         for node in self.graph[s]:
                               if visited.count(node[1]       ) < 1:
                                     d.append(node[1]       )
                                     visited.append(node[1]       )
             return visited





       def 						lowerCAmelCase     (   self							:			Union[str, Any]					,      __lowerCamelCase							:			Any       ):


             '''simple docstring'''



             lowerCamelCase__		:				Union[str, Any]    =  0
             for x in self.graph:
                   for y in self.graph[x]:
                         if y[1] == u:
                               count += 1
             return count





       def 						lowerCAmelCase     (   self							:			List[str]					,      __lowerCamelCase							:			Tuple       ):


             '''simple docstring'''



             return len(self.graph[u]       )





       def 						lowerCAmelCase     (   self							:			List[Any]					,      __lowerCamelCase							:			str=-2       ):


             '''simple docstring'''



             lowerCamelCase__		:				str    =  []
             lowerCamelCase__		:				Dict    =  []
             if s == -2:
                   lowerCamelCase__		:				List[str]    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				int    =  s
             lowerCamelCase__		:				Optional[Any]    =  []

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				List[str]    =  s
                         for node in self.graph[s]:
                               if visited.count(node[1]       ) < 1:
                                     stack.append(node[1]       )
                                     visited.append(node[1]       )
                                     lowerCamelCase__		:				Optional[int]    =  node[1]
                                     break

            # check if all the children are visited
                   if s == ss:
                         sorted_nodes.append(stack.pop()       )
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				Dict    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				Union[str, Any]    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return sorted_nodes





       def 						lowerCAmelCase     (   self							:			Optional[Any]       ):


             '''simple docstring'''



             lowerCamelCase__		:				List[Any]    =  []
             lowerCamelCase__		:				Tuple    =  []
             lowerCamelCase__		:				str    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				Dict    =  -2
             lowerCamelCase__		:				Union[str, Any]    =  []
             lowerCamelCase__		:				str    =  s
             lowerCamelCase__		:				str    =  False
             lowerCamelCase__		:				Optional[int]    =  set()

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				Optional[Any]    =  s
                         for node in self.graph[s]:
                               if (
                                   visited.count(node[1]       ) > 0
                                   and node[1] != parent
                                   and indirect_parents.count(node[1]       ) > 0
                                   and not on_the_way_back
                               ):
                                     lowerCamelCase__		:				Dict    =  len(__lowerCAmelCase       ) - 1
                                     while len_stack >= 0:
                                           if stack[len_stack] == node[1]:
                                                 anticipating_nodes.add(node[1]       )
                                                 break
                                           else:
                                                 anticipating_nodes.add(stack[len_stack]       )
                                                 len_stack -= 1
                               if visited.count(node[1]       ) < 1:
                                     stack.append(node[1]       )
                                     visited.append(node[1]       )
                                     lowerCamelCase__		:				List[str]    =  node[1]
                                     break

            # check if all the children are visited
                   if s == ss:
                         stack.pop()
                         lowerCamelCase__		:				Optional[Any]    =  True
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				List[str]    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				str    =  False
                         indirect_parents.append(__lowerCAmelCase       )
                         lowerCamelCase__		:				Tuple    =  s
                         lowerCamelCase__		:				int    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return list(__lowerCAmelCase       )





       def 						lowerCAmelCase     (   self							:			Optional[int]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Tuple    =  []
             lowerCamelCase__		:				List[str]    =  []
             lowerCamelCase__		:				int    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				int    =  -2
             lowerCamelCase__		:				Optional[Any]    =  []
             lowerCamelCase__		:				Tuple    =  s
             lowerCamelCase__		:				Any    =  False
             lowerCamelCase__		:				Dict    =  set()

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				Tuple    =  s
                         for node in self.graph[s]:
                               if (
                                   visited.count(node[1]       ) > 0
                                   and node[1] != parent
                                   and indirect_parents.count(node[1]       ) > 0
                                   and not on_the_way_back
                               ):
                                     lowerCamelCase__		:				Optional[Any]    =  len(__lowerCAmelCase       ) - 1
                                     while len_stack_minus_one >= 0:
                                           if stack[len_stack_minus_one] == node[1]:
                                                 anticipating_nodes.add(node[1]       )
                                                 break
                                           else:
                                                 return True
                               if visited.count(node[1]       ) < 1:
                                     stack.append(node[1]       )
                                     visited.append(node[1]       )
                                     lowerCamelCase__		:				Optional[Any]    =  node[1]
                                     break

            # check if all the children are visited
                   if s == ss:
                         stack.pop()
                         lowerCamelCase__		:				str    =  True
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				Dict    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				Optional[Any]    =  False
                         indirect_parents.append(__lowerCAmelCase       )
                         lowerCamelCase__		:				Any    =  s
                         lowerCamelCase__		:				Union[str, Any]    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return False





       def 						lowerCAmelCase     (   self							:			int					,      __lowerCamelCase							:			int=-2					,      __lowerCamelCase							:			Optional[Any]=-1       ):


             '''simple docstring'''



             lowerCamelCase__		:				List[str]    =  time()
             self.dfs(__lowerCAmelCase					,      __lowerCAmelCase       )
             lowerCamelCase__		:				Dict    =  time()
             return end - begin





       def 						lowerCAmelCase     (   self							:			List[Any]					,      __lowerCamelCase							:			Tuple=-2       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[Any]    =  time()
             self.bfs(__lowerCAmelCase       )
             lowerCamelCase__		:				List[str]    =  time()
             return end - begin







class 			_lowercase :


       """simple docstring"""




       def __init__(   self							:			Optional[Any]       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[Any]    =  {}





       def 						lowerCAmelCase     (   self							:			int					,      __lowerCamelCase							:			Optional[int]					,      __lowerCamelCase							:			Any					,      __lowerCamelCase							:			Dict=1       ):


             '''simple docstring'''



             if self.graph.get(__lowerCAmelCase       ):
                   # if there already is a edge
                   if self.graph[u].count([w, v]       ) == 0:
                         self.graph[u].append([w, v]       )
             else:
                   # if u does not exist
                   lowerCamelCase__		:				Union[str, Any]    =  [[w, v]]
             # add the other way
             if self.graph.get(__lowerCAmelCase       ):
                   # if there already is a edge
                   if self.graph[v].count([w, u]       ) == 0:
                         self.graph[v].append([w, u]       )
             else:
                   # if u does not exist
                   lowerCamelCase__		:				Any    =  [[w, u]]





       def 						lowerCAmelCase     (   self							:			Optional[Any]					,      __lowerCamelCase							:			Dict					,      __lowerCamelCase							:			List[str]       ):


             '''simple docstring'''



             if self.graph.get(__lowerCAmelCase       ):
                   for _ in self.graph[u]:
                         if _[1] == v:
                               self.graph[u].remove(__lowerCAmelCase       )
        # the other way round
             if self.graph.get(__lowerCAmelCase       ):
                   for _ in self.graph[v]:
                         if _[1] == u:
                               self.graph[v].remove(__lowerCAmelCase       )





       def 						lowerCAmelCase     (   self							:			Dict					,      __lowerCamelCase							:			List[str]=-2					,      __lowerCamelCase							:			Optional[Any]=-1       ):


             '''simple docstring'''



             if s == d:
                   return []
             lowerCamelCase__		:				int    =  []
             lowerCamelCase__		:				Optional[Any]    =  []
             if s == -2:
                   lowerCamelCase__		:				Any    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				int    =  s

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				Optional[Any]    =  s
                         for node in self.graph[s]:
                               if visited.count(node[1]       ) < 1:
                                     if node[1] == d:
                                           visited.append(__lowerCAmelCase       )
                                           return visited
                                     else:
                                           stack.append(node[1]       )
                                           visited.append(node[1]       )
                                           lowerCamelCase__		:				List[Any]    =  node[1]
                                           break

            # check if all the children are visited
                   if s == ss:
                         stack.pop()
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				List[str]    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				Dict    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return visited





       def 						lowerCAmelCase     (   self							:			Optional[Any]					,      __lowerCamelCase							:			Any=-1       ):


             '''simple docstring'''



             if c == -1:
                   lowerCamelCase__		:				Union[str, Any]    =  floor(random() * 10000       ) + 10
             for i in range(__lowerCAmelCase       ):
                   # every vertex has max 100 edges
                   for _ in range(floor(random() * 102       ) + 1       ):
                         lowerCamelCase__		:				Optional[Any]    =  floor(random() * c       ) + 1
                         if n != i:
                               self.add_pair(__lowerCAmelCase					,      __lowerCAmelCase					,      1       )





       def 						lowerCAmelCase     (   self							:			Any					,      __lowerCamelCase							:			Optional[Any]=-2       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[Any]    =  deque()
             lowerCamelCase__		:				Optional[Any]    =  []
             if s == -2:
                   lowerCamelCase__		:				List[Any]    =  list(self.graph       )[0]
             d.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             while d:
                   lowerCamelCase__		:				Tuple    =  d.popleft()
                   if len(self.graph[s]       ) != 0:
                         for node in self.graph[s]:
                               if visited.count(node[1]       ) < 1:
                                     d.append(node[1]       )
                                     visited.append(node[1]       )
             return visited





       def 						lowerCAmelCase     (   self							:			str					,      __lowerCamelCase							:			List[str]       ):


             '''simple docstring'''



             return len(self.graph[u]       )





       def 						lowerCAmelCase     (   self							:			int       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[int]    =  []
             lowerCamelCase__		:				int    =  []
             lowerCamelCase__		:				int    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				int    =  -2
             lowerCamelCase__		:				Optional[Any]    =  []
             lowerCamelCase__		:				int    =  s
             lowerCamelCase__		:				Optional[Any]    =  False
             lowerCamelCase__		:				Optional[int]    =  set()

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				List[str]    =  s
                         for node in self.graph[s]:
                               if (
                                   visited.count(node[1]       ) > 0
                                   and node[1] != parent
                                   and indirect_parents.count(node[1]       ) > 0
                                   and not on_the_way_back
                               ):
                                     lowerCamelCase__		:				str    =  len(__lowerCAmelCase       ) - 1
                                     while len_stack >= 0:
                                           if stack[len_stack] == node[1]:
                                                 anticipating_nodes.add(node[1]       )
                                                 break
                                           else:
                                                 anticipating_nodes.add(stack[len_stack]       )
                                                 len_stack -= 1
                               if visited.count(node[1]       ) < 1:
                                     stack.append(node[1]       )
                                     visited.append(node[1]       )
                                     lowerCamelCase__		:				Union[str, Any]    =  node[1]
                                     break

            # check if all the children are visited
                   if s == ss:
                         stack.pop()
                         lowerCamelCase__		:				Union[str, Any]    =  True
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				Dict    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				Dict    =  False
                         indirect_parents.append(__lowerCAmelCase       )
                         lowerCamelCase__		:				int    =  s
                         lowerCamelCase__		:				str    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return list(__lowerCAmelCase       )





       def 						lowerCAmelCase     (   self							:			Dict       ):


             '''simple docstring'''



             lowerCamelCase__		:				Optional[Any]    =  []
             lowerCamelCase__		:				str    =  []
             lowerCamelCase__		:				Any    =  list(self.graph       )[0]
             stack.append(__lowerCAmelCase       )
             visited.append(__lowerCAmelCase       )
             lowerCamelCase__		:				List[Any]    =  -2
             lowerCamelCase__		:				Optional[Any]    =  []
             lowerCamelCase__		:				Union[str, Any]    =  s
             lowerCamelCase__		:				Union[str, Any]    =  False
             lowerCamelCase__		:				Dict    =  set()

             while True:
                   # check if there is any non isolated nodes
                   if len(self.graph[s]       ) != 0:
                         lowerCamelCase__		:				Union[str, Any]    =  s
                         for node in self.graph[s]:
                               if (
                                   visited.count(node[1]       ) > 0
                                   and node[1] != parent
                                   and indirect_parents.count(node[1]       ) > 0
                                   and not on_the_way_back
                               ):
                                     lowerCamelCase__		:				Union[str, Any]    =  len(__lowerCAmelCase       ) - 1
                                     while len_stack_minus_one >= 0:
                                           if stack[len_stack_minus_one] == node[1]:
                                                 anticipating_nodes.add(node[1]       )
                                                 break
                                           else:
                                                 return True
                               if visited.count(node[1]       ) < 1:
                                     stack.append(node[1]       )
                                     visited.append(node[1]       )
                                     lowerCamelCase__		:				int    =  node[1]
                                     break

            # check if all the children are visited
                   if s == ss:
                         stack.pop()
                         lowerCamelCase__		:				str    =  True
                         if len(__lowerCAmelCase       ) != 0:
                               lowerCamelCase__		:				int    =  stack[len(__lowerCAmelCase       ) - 1]
                   else:
                         lowerCamelCase__		:				str    =  False
                         indirect_parents.append(__lowerCAmelCase       )
                         lowerCamelCase__		:				Dict    =  s
                         lowerCamelCase__		:				List[str]    =  ss

                   # check if se have reached the starting point
                   if len(__lowerCAmelCase       ) == 0:
                         return False





       def 						lowerCAmelCase     (   self							:			List[Any]       ):


             '''simple docstring'''



             return list(self.graph       )





       def 						lowerCAmelCase     (   self							:			List[str]					,      __lowerCamelCase							:			List[str]=-2					,      __lowerCamelCase							:			int=-1       ):


             '''simple docstring'''



             lowerCamelCase__		:				Union[str, Any]    =  time()
             self.dfs(__lowerCAmelCase					,      __lowerCAmelCase       )
             lowerCamelCase__		:				List[Any]    =  time()
             return end - begin





       def 						lowerCAmelCase     (   self							:			Optional[int]					,      __lowerCamelCase							:			Tuple=-2       ):


             '''simple docstring'''



             lowerCamelCase__		:				List[Any]    =  time()
             self.bfs(__lowerCAmelCase       )
             lowerCamelCase__		:				Union[str, Any]    =  time()
             return end - begin









from collections import deque


class   A			:
			'''simple docstring'''




			def __init__(			self   :    List[str]							,	__lowerCAmelCase   :    str							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    int   )	->	None:







					"""simple docstring"""






					A__        =   process_name  # process name
					A__        =   arrival_time  # arrival time of the process
					# completion time of finished process or last interrupted time
					A__        =   arrival_time
					A__        =   burst_time  # remaining burst time
					A__        =   0  # total time of the process wait in ready queue
					A__        =   0  # time from arrival time to completion time


class   A			:
			'''simple docstring'''




			def __init__(			self   :    Tuple							,	__lowerCAmelCase   :    int							,	__lowerCAmelCase   :    list[int]							,	__lowerCAmelCase   :    deque[Process]							,	__lowerCAmelCase   :    int							,	)	->	None:







					"""simple docstring"""






					A__        =   number_of_queues
					# time slice of queues that round robin algorithm applied
					A__        =   time_slices
					# unfinished process is in this ready_queue
					A__        =   queue
					# current time
					A__        =   current_time
					# finished process is in this sequence queue
					A__        =   deque()






			def    a_       (			self   :    Dict   )	->	list[str]:







					"""simple docstring"""






					A__        =   []
					for i in range(len(self.finish_queue   )   ):
							sequence.append(self.finish_queue[i].process_name   )
					return sequence






			def    a_       (			self   :    Tuple							,	__lowerCAmelCase   :    list[Process]   )	->	list[int]:







					"""simple docstring"""






					A__        =   []
					for i in range(len(__lowerCAmelCase   )   ):
							waiting_times.append(queue[i].waiting_time   )
					return waiting_times






			def    a_       (			self   :    Optional[Any]							,	__lowerCAmelCase   :    list[Process]   )	->	list[int]:







					"""simple docstring"""






					A__        =   []
					for i in range(len(__lowerCAmelCase   )   ):
							turnaround_times.append(queue[i].turnaround_time   )
					return turnaround_times






			def    a_       (			self   :    Dict							,	__lowerCAmelCase   :    list[Process]   )	->	list[int]:







					"""simple docstring"""






					A__        =   []
					for i in range(len(__lowerCAmelCase   )   ):
							completion_times.append(queue[i].stop_time   )
					return completion_times






			def    a_       (			self   :    int							,	__lowerCAmelCase   :    deque[Process]   )	->	list[int]:







					"""simple docstring"""






					return [q.burst_time for q in queue]






			def    a_       (			self   :    Any							,	__lowerCAmelCase   :    Process   )	->	int:







					"""simple docstring"""






					process.waiting_time += self.current_time - process.stop_time
					return process.waiting_time






			def    a_       (			self   :    Union[str, Any]							,	__lowerCAmelCase   :    deque[Process]   )	->	deque[Process]:







					"""simple docstring"""






					A__        =   deque()  # sequence deque of finished process
					while len(__lowerCAmelCase   ) != 0:
							A__        =   ready_queue.popleft()  # current process

							# if process's arrival time is later than current time, update current time
							if self.current_time < cp.arrival_time:
									self.current_time += cp.arrival_time

							# update waiting time of current process
							self.update_waiting_time(__lowerCAmelCase   )
							# update current time
							self.current_time += cp.burst_time
							# finish the process and set the process's burst-time 0
							A__        =   0
							# set the process's turnaround time because it is finished
							A__        =   self.current_time - cp.arrival_time
							# set the completion time
							A__        =   self.current_time
							# add the process to queue that has finished queue
							finished.append(__lowerCAmelCase   )

					self.finish_queue.extend(__lowerCAmelCase   )  # add finished process to finish queue
					# FCFS will finish all remaining processes
					return finished






			def    a_       (			self   :    Optional[Any]							,	__lowerCAmelCase   :    deque[Process]							,	__lowerCAmelCase   :    int   )	->	tuple[deque[Process], deque[Process]]:







					"""simple docstring"""






					A__        =   deque()  # sequence deque of terminated process
					# just for 1 cycle and unfinished processes will go back to queue
					for _ in range(len(__lowerCAmelCase   )   ):
							A__        =   ready_queue.popleft()  # current process

							# if process's arrival time is later than current time, update current time
							if self.current_time < cp.arrival_time:
									self.current_time += cp.arrival_time

							# update waiting time of unfinished processes
							self.update_waiting_time(__lowerCAmelCase   )
							# if the burst time of process is bigger than time-slice
							if cp.burst_time > time_slice:
									# use CPU for only time-slice
									self.current_time += time_slice
									# update remaining burst time
									cp.burst_time -= time_slice
									# update end point time
									A__        =   self.current_time
									# locate the process behind the queue because it is not finished
									ready_queue.append(__lowerCAmelCase   )
							else:
									# use CPU for remaining burst time
									self.current_time += cp.burst_time
									# set burst time 0 because the process is finished
									A__        =   0
									# set the finish time
									A__        =   self.current_time
									# update the process' turnaround time because it is finished
									A__        =   self.current_time - cp.arrival_time
									# add the process to queue that has finished queue
									finished.append(__lowerCAmelCase   )

					self.finish_queue.extend(__lowerCAmelCase   )  # add finished process to finish queue
					# return finished processes queue and remaining processes queue
					return finished, ready_queue







			def    a_       (			self   :    List[Any]   )	->	deque[Process]:







					"""simple docstring"""






					for i in range(self.number_of_queues - 1   ):
							A__      ,			A__        =   self.round_robin(
							    self.ready_queue							,	self.time_slices[i]   )
					#  the last queue has first_come_first_served algorithm
					self.first_come_first_served(self.ready_queue   )

					return self.finish_queue


if __name__ == "__main__":
					import doctest

					A    :					Union[str, Any] =      Process('''P1''', 0, 5_3)
					A    :					Optional[Any] =      Process('''P2''', 0, 1_7)
					A    :					Optional[int] =      Process('''P3''', 0, 6_8)
					A    :					int =      Process('''P4''', 0, 2_4)
					A    :					Any =      3
					A    :					List[Any] =      [1_7, 2_5]
					A    :					Optional[Any] =      deque([Pa, Pa, Pa, Pa])

					if len(time_slices) != number_of_queues - 1:
										raise SystemExit(0)

					doctest.testmod(extraglobs={'''queue''': deque([Pa, Pa, Pa, Pa])})

					A    :					Optional[Any] =      Process('''P1''', 0, 5_3)
					A    :					int =      Process('''P2''', 0, 1_7)
					A    :					Optional[int] =      Process('''P3''', 0, 6_8)
					A    :					Tuple =      Process('''P4''', 0, 2_4)
					A    :					Union[str, Any] =      3
					A    :					Optional[Any] =      [1_7, 2_5]
					A    :					Tuple =      deque([Pa, Pa, Pa, Pa])
					A    :					Optional[int] =      MLFQ(number_of_queues, time_slices, queue, 0)
					A    :					Dict =      mlfq.multi_level_feedback_queue()

					# print total waiting times of processes(P1, P2, P3, P4)
					print(
					    F'''waiting time:\
        \t\t\t{MLFQ.calculate_waiting_time(mlfq, [Pa, Pa, Pa, Pa])}'''
					)
					# print completion times of processes(P1, P2, P3, P4)
					print(
					    F'''completion time:\
        \t\t{MLFQ.calculate_completion_time(mlfq, [Pa, Pa, Pa, Pa])}'''
					)
					# print total turnaround times of processes(P1, P2, P3, P4)
					print(
					    F'''turnaround time:\
        \t\t{MLFQ.calculate_turnaround_time(mlfq, [Pa, Pa, Pa, Pa])}'''
					)
					# print sequence of finished processes
					print(
					    F'''sequence of finished processes:\
        {mlfq.calculate_sequence_of_finish_queue()}'''
					)



