






'''simple docstring'''







from collections import deque





class 						SCREAMING_SNAKE_CASE       :






			def __init__(			self   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      str	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      None:
							a_		:	Union[str, Any]									=   process_name  # process name
							a_		:	str									=   arrival_time  # arrival time of the process
							# completion time of finished process or last interrupted time
							a_		:	Tuple									=   arrival_time
							a_		:	Dict									=   burst_time  # remaining burst time
							a_		:	Any									=   0  # total time of the process wait in ready queue
							a_		:	Tuple									=   0  # time from arrival time to completion time





class 						SCREAMING_SNAKE_CASE       :






			def __init__(			self   :      Optional[Any]	,    __SCREAMING_SNAKE_CASE   :      int	,    __SCREAMING_SNAKE_CASE   :      list[int]	,    __SCREAMING_SNAKE_CASE   :      deque[Process]	,    __SCREAMING_SNAKE_CASE   :      int	,    )      ->      None:
							# total number of mlfq's queues
							a_		:	int									=   number_of_queues
							# time slice of queues that round robin algorithm applied
							a_		:	Optional[int]									=   time_slices
							# unfinished process is in this ready_queue
							a_		:	Any									=   queue
							# current time
							a_		:	str									=   current_time
							# finished process is in this sequence queue
							a_		:	deque[Process]									=   deque()






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]       )      ->      list[str]:
							a_		:	List[str]									=   []
							for i in range(len(self.finish_queue       )       ):
											sequence.append(self.finish_queue[i].process_name       )
							return sequence






			def       SCREAMING_SNAKE_CASE   (			self   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      list[Process]       )      ->      list[int]:
							a_		:	str									=   []
							for i in range(len(__SCREAMING_SNAKE_CASE       )       ):
											waiting_times.append(queue[i].waiting_time       )
							return waiting_times






			def       SCREAMING_SNAKE_CASE   (			self   :      Optional[int]	,    __SCREAMING_SNAKE_CASE   :      list[Process]       )      ->      list[int]:
							a_		:	List[str]									=   []
							for i in range(len(__SCREAMING_SNAKE_CASE       )       ):
											turnaround_times.append(queue[i].turnaround_time       )
							return turnaround_times






			def       SCREAMING_SNAKE_CASE   (			self   :      str	,    __SCREAMING_SNAKE_CASE   :      list[Process]       )      ->      list[int]:
							a_		:	Any									=   []
							for i in range(len(__SCREAMING_SNAKE_CASE       )       ):
											completion_times.append(queue[i].stop_time       )
							return completion_times






			def       SCREAMING_SNAKE_CASE   (			self   :      Tuple	,    __SCREAMING_SNAKE_CASE   :      deque[Process]       )      ->      list[int]:
							return [q.burst_time for q in queue]






			def       SCREAMING_SNAKE_CASE   (			self   :      List[str]	,    __SCREAMING_SNAKE_CASE   :      Process       )      ->      int:
							process.waiting_time += self.current_time - process.stop_time
							return process.waiting_time






			def       SCREAMING_SNAKE_CASE   (			self   :      Any	,    __SCREAMING_SNAKE_CASE   :      deque[Process]       )      ->      deque[Process]:
							a_		:	deque[Process]									=   deque()  # sequence deque of finished process
							while len(__SCREAMING_SNAKE_CASE       ) != 0:
											a_		:	List[str]									=   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(__SCREAMING_SNAKE_CASE       )
											# update current time
											self.current_time += cp.burst_time
											# finish the process and set the process's burst-time 0
											a_		:	Tuple									=   0
											# set the process's turnaround time because it is finished
											a_		:	Union[str, Any]									=   self.current_time - cp.arrival_time
											# set the completion time
											a_		:	Union[str, Any]									=   self.current_time
											# add the process to queue that has finished queue
											finished.append(__SCREAMING_SNAKE_CASE       )

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






			def       SCREAMING_SNAKE_CASE   (			self   :      Union[str, Any]	,    __SCREAMING_SNAKE_CASE   :      deque[Process]	,    __SCREAMING_SNAKE_CASE   :      int       )      ->      tuple[deque[Process], deque[Process]]:
							a_		:	deque[Process]									=   deque()  # sequence deque of terminated process
							# just for 1 cycle and unfinished processes will go back to queue
							for _ in range(len(__SCREAMING_SNAKE_CASE       )       ):
											a_		:	str									=   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(__SCREAMING_SNAKE_CASE       )
											# 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_		:	Dict									=   self.current_time
															# locate the process behind the queue because it is not finished
															ready_queue.append(__SCREAMING_SNAKE_CASE       )
											else:
															# use CPU for remaining burst time
															self.current_time += cp.burst_time
															# set burst time 0 because the process is finished
															a_		:	str									=   0
															# set the finish time
															a_		:	Optional[Any]									=   self.current_time
															# update the process' turnaround time because it is finished
															a_		:	Union[str, Any]									=   self.current_time - cp.arrival_time
															# add the process to queue that has finished queue
															finished.append(__SCREAMING_SNAKE_CASE       )

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







			def       SCREAMING_SNAKE_CASE   (			self   :      int       )      ->      deque[Process]:

							#  all queues except last one have round_robin algorithm
							for i in range(self.number_of_queues - 1       ):
											a_					,      a_		:	int									=   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

		__lowerCAmelCase									=   Process('P1', 0, 53)
		__lowerCAmelCase									=   Process('P2', 0, 17)
		__lowerCAmelCase									=   Process('P3', 0, 68)
		__lowerCAmelCase									=   Process('P4', 0, 24)
		__lowerCAmelCase									=   3
		__lowerCAmelCase									=   [17, 25]
		__lowerCAmelCase									=   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])})

		__lowerCAmelCase									=   Process('P1', 0, 53)
		__lowerCAmelCase									=   Process('P2', 0, 17)
		__lowerCAmelCase									=   Process('P3', 0, 68)
		__lowerCAmelCase									=   Process('P4', 0, 24)
		__lowerCAmelCase									=   3
		__lowerCAmelCase									=   [17, 25]
		__lowerCAmelCase									=   deque([Pa, Pa, Pa, Pa])
		__lowerCAmelCase									=   MLFQ(number_of_queues, time_slices, queue, 0)
		__lowerCAmelCase									=   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()}"""
		)












'''simple docstring'''







import math





def 		_UpperCAmelCase (				__A				: int   ):
				a_		:	str									=   []
				a_		:	Tuple									=   2
				a_		:	Optional[Any]									=   int(math.sqrt(__A   )   )  # Size of every segment
				a_		:	Optional[Any]									=   [True] * (end + 1)
				a_		:	Union[str, Any]									=   []

				while start <= end:
								if temp[start] is True:
												in_prime.append(__A   )
												for i in range(start * start    ,		end + 1    ,		__A   ):
																a_		:	List[Any]									=   False
								start += 1
				prime += in_prime

				a_		:	Any									=   end + 1
				a_		:	Optional[Any]									=   min(2 * end    ,		__A   )

				while low <= n:
								a_		:	Optional[Any]									=   [True] * (high - low + 1)
								for each in in_prime:
												a_		:	Any									=   math.floor(low / each   ) * each
												if t < low:
																t += each

												for j in range(__A    ,		high + 1    ,		__A   ):
																a_		:	Union[str, Any]									=   False

								for j in range(len(__A   )   ):
												if temp[j] is True:
																prime.append(j + low   )

								a_		:	Tuple									=   high + 1
								a_		:	str									=   min(high + end    ,		__A   )

				return prime




print(sieve(10**6))




