



"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import MobileBertConfig, is_tf_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
				import tensorflow as tf

				from transformers import (
				    TF_MODEL_FOR_PRETRAINING_MAPPING,
				    TFMobileBertForMaskedLM,
				    TFMobileBertForMultipleChoice,
				    TFMobileBertForNextSentencePrediction,
				    TFMobileBertForPreTraining,
				    TFMobileBertForQuestionAnswering,
				    TFMobileBertForSequenceClassification,
				    TFMobileBertForTokenClassification,
				    TFMobileBertModel,
				)







@require_tf
class 				A_      (					SCREAMING_SNAKE_CASE_     ,       SCREAMING_SNAKE_CASE_     ,       unittest.TestCase    ):



						"""simple docstring"""
						__UpperCamelCase		    =							(
						    (
						        TFMobileBertModel,
						        TFMobileBertForMaskedLM,
						        TFMobileBertForNextSentencePrediction,
						        TFMobileBertForPreTraining,
						        TFMobileBertForQuestionAnswering,
						        TFMobileBertForSequenceClassification,
						        TFMobileBertForTokenClassification,
						        TFMobileBertForMultipleChoice,
						    )
						    if is_tf_available()
						    else ()
						)
						__UpperCamelCase		    =							(
						    {
						        """feature-extraction""": TFMobileBertModel,
						        """fill-mask""": TFMobileBertForMaskedLM,
						        """question-answering""": TFMobileBertForQuestionAnswering,
						        """text-classification""": TFMobileBertForSequenceClassification,
						        """token-classification""": TFMobileBertForTokenClassification,
						        """zero-shot""": TFMobileBertForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						__UpperCamelCase		    =							False
						__UpperCamelCase		    =							False






						def      UpperCAmelCase__					( self			:int       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[Any]       ,  lowercase_			:Optional[Any]=False )    ->      List[str]:
												UpperCAmelCase					=			super()._prepare_for_class(lowercase_       ,  lowercase_       ,  return_labels=lowercase_ )

												if return_labels:
																		if model_class in get_values(lowercase_ ):
																								UpperCAmelCase					=			tf.zeros(self.model_tester.batch_size       ,  dtype=tf.intaa )

												return inputs_dict







						class 				A_      (					SCREAMING_SNAKE_CASE_    ):



												"""simple docstring"""






												def __init__( self			:Optional[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:str=13       ,  lowercase_			:Dict=7       ,  lowercase_			:List[str]=True       ,  lowercase_			:Union[str, Any]=True       ,  lowercase_			:Any=True       ,  lowercase_			:List[str]=True       ,  lowercase_			:Any=99       ,  lowercase_			:int=32       ,  lowercase_			:List[Any]=32       ,  lowercase_			:Optional[Any]=2       ,  lowercase_			:str=4       ,  lowercase_			:List[str]=37       ,  lowercase_			:List[Any]="gelu"       ,  lowercase_			:Any=0.1       ,  lowercase_			:Dict=0.1       ,  lowercase_			:List[Any]=5_12       ,  lowercase_			:List[str]=16       ,  lowercase_			:Dict=2       ,  lowercase_			:Optional[Any]=0.02       ,  lowercase_			:Optional[Any]=3       ,  lowercase_			:List[Any]=4       ,  lowercase_			:Tuple=None       ,  )    ->      str:
																		UpperCAmelCase					=			parent
																		UpperCAmelCase					=			batch_size
																		UpperCAmelCase					=			seq_length
																		UpperCAmelCase					=			is_training
																		UpperCAmelCase					=			use_input_mask
																		UpperCAmelCase					=			use_token_type_ids
																		UpperCAmelCase					=			use_labels
																		UpperCAmelCase					=			vocab_size
																		UpperCAmelCase					=			hidden_size
																		UpperCAmelCase					=			num_hidden_layers
																		UpperCAmelCase					=			num_attention_heads
																		UpperCAmelCase					=			intermediate_size
																		UpperCAmelCase					=			hidden_act
																		UpperCAmelCase					=			hidden_dropout_prob
																		UpperCAmelCase					=			attention_probs_dropout_prob
																		UpperCAmelCase					=			max_position_embeddings
																		UpperCAmelCase					=			type_vocab_size
																		UpperCAmelCase					=			type_sequence_label_size
																		UpperCAmelCase					=			initializer_range
																		UpperCAmelCase					=			num_labels
																		UpperCAmelCase					=			num_choices
																		UpperCAmelCase					=			scope
																		UpperCAmelCase					=			embedding_size






												def      UpperCAmelCase__					( self			:Optional[Any] )    ->      List[Any]:
																		UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size )

																		UpperCAmelCase					=			None
																		if self.use_input_mask:
																								UpperCAmelCase					=			random_attention_mask([self.batch_size, self.seq_length] )

																		UpperCAmelCase					=			None
																		if self.use_token_type_ids:
																								UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  self.type_vocab_size )

																		UpperCAmelCase					=			None
																		UpperCAmelCase					=			None
																		UpperCAmelCase					=			None
																		if self.use_labels:
																								UpperCAmelCase					=			ids_tensor([self.batch_size]       ,  self.type_sequence_label_size )
																								UpperCAmelCase					=			ids_tensor([self.batch_size, self.seq_length]       ,  self.num_labels )
																								UpperCAmelCase					=			ids_tensor([self.batch_size]       ,  self.num_choices )

																		UpperCAmelCase					=			MobileBertConfig(
																		    vocab_size=self.vocab_size       ,  hidden_size=self.hidden_size       ,  num_hidden_layers=self.num_hidden_layers       ,  num_attention_heads=self.num_attention_heads       ,  intermediate_size=self.intermediate_size       ,  hidden_act=self.hidden_act       ,  hidden_dropout_prob=self.hidden_dropout_prob       ,  attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,  max_position_embeddings=self.max_position_embeddings       ,  type_vocab_size=self.type_vocab_size       ,  initializer_range=self.initializer_range       ,  embedding_size=self.embedding_size       ,  )

																		return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






												def      UpperCAmelCase__					( self			:Any       ,  lowercase_			:Dict       ,  lowercase_			:str       ,  lowercase_			:Tuple       ,  lowercase_			:int       ,  lowercase_			:str       ,  lowercase_			:str       ,  lowercase_			:Optional[Any] )    ->      int:
																		UpperCAmelCase					=			TFMobileBertModel(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )

																		UpperCAmelCase					=			[input_ids, input_mask]
																		UpperCAmelCase					=			model(lowercase_ )

																		UpperCAmelCase					=			model(lowercase_ )

																		self.parent.assertEqual(
																		    result.last_hidden_state.shape       ,  (self.batch_size, self.seq_length, self.hidden_size) )
																		self.parent.assertEqual(result.pooler_output.shape       ,  (self.batch_size, self.hidden_size) )






												def      UpperCAmelCase__					( self			:List[Any]       ,  lowercase_			:Tuple       ,  lowercase_			:int       ,  lowercase_			:Dict       ,  lowercase_			:List[str]       ,  lowercase_			:Tuple       ,  lowercase_			:Any       ,  lowercase_			:int )    ->      str:
																		UpperCAmelCase					=			TFMobileBertForMaskedLM(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size) )






												def      UpperCAmelCase__					( self			:Union[str, Any]       ,  lowercase_			:Tuple       ,  lowercase_			:int       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:List[str]       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Dict )    ->      List[str]:
																		UpperCAmelCase					=			TFMobileBertForNextSentencePrediction(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, 2) )






												def      UpperCAmelCase__					( self			:Dict       ,  lowercase_			:Dict       ,  lowercase_			:Tuple       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Any       ,  lowercase_			:int       ,  lowercase_			:Optional[int]       ,  lowercase_			:Optional[int] )    ->      List[Any]:
																		UpperCAmelCase					=			TFMobileBertForPreTraining(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(
																		    result.prediction_logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size) )
																		self.parent.assertEqual(result.seq_relationship_logits.shape       ,  (self.batch_size, 2) )






												def      UpperCAmelCase__					( self			:Tuple       ,  lowercase_			:Dict       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Tuple       ,  lowercase_			:Tuple       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Dict )    ->      Optional[Any]:
																		UpperCAmelCase					=			self.num_labels
																		UpperCAmelCase					=			TFMobileBertForSequenceClassification(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels) )






												def      UpperCAmelCase__					( self			:str       ,  lowercase_			:Tuple       ,  lowercase_			:str       ,  lowercase_			:Optional[Any]       ,  lowercase_			:int       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Optional[Any]       ,  lowercase_			:List[Any] )    ->      str:
																		UpperCAmelCase					=			self.num_choices
																		UpperCAmelCase					=			TFMobileBertForMultipleChoice(config=lowercase_ )
																		UpperCAmelCase					=			tf.tile(tf.expand_dims(lowercase_       ,  1 )       ,  (1, self.num_choices, 1) )
																		UpperCAmelCase					=			tf.tile(tf.expand_dims(lowercase_       ,  1 )       ,  (1, self.num_choices, 1) )
																		UpperCAmelCase					=			tf.tile(tf.expand_dims(lowercase_       ,  1 )       ,  (1, self.num_choices, 1) )
																		UpperCAmelCase					=			{
																		    'input_ids': multiple_choice_inputs_ids,
																		    'attention_mask': multiple_choice_input_mask,
																		    'token_type_ids': multiple_choice_token_type_ids,
																		}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_choices) )






												def      UpperCAmelCase__					( self			:int       ,  lowercase_			:Tuple       ,  lowercase_			:Optional[Any]       ,  lowercase_			:str       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Optional[Any]       ,  lowercase_			:Optional[int]       ,  lowercase_			:int )    ->      Union[str, Any]:
																		UpperCAmelCase					=			self.num_labels
																		UpperCAmelCase					=			TFMobileBertForTokenClassification(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.num_labels) )






												def      UpperCAmelCase__					( self			:str       ,  lowercase_			:int       ,  lowercase_			:Union[str, Any]       ,  lowercase_			:Optional[int]       ,  lowercase_			:Dict       ,  lowercase_			:Any       ,  lowercase_			:Tuple       ,  lowercase_			:Any )    ->      Union[str, Any]:
																		UpperCAmelCase					=			TFMobileBertForQuestionAnswering(config=lowercase_ )
																		UpperCAmelCase					=			{'input_ids': input_ids, 'attention_mask': input_mask, 'token_type_ids': token_type_ids}
																		UpperCAmelCase					=			model(lowercase_ )
																		self.parent.assertEqual(result.start_logits.shape       ,  (self.batch_size, self.seq_length) )
																		self.parent.assertEqual(result.end_logits.shape       ,  (self.batch_size, self.seq_length) )






												def      UpperCAmelCase__					( self			:List[Any] )    ->      Any:
																		UpperCAmelCase					=			self.prepare_config_and_inputs()
																		(
																		    (
																		    UpperCAmelCase
																		)				,   (
																		    UpperCAmelCase
																		)				,   (
																		    UpperCAmelCase
																		)				,   (
																		    UpperCAmelCase
																		)				,   (
																		    UpperCAmelCase
																		)				,   (
																		    UpperCAmelCase
																		)				,   (
																		    UpperCAmelCase
																		)				,   
																		)					=			config_and_inputs
																		UpperCAmelCase					=			{'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
																		return config, inputs_dict






						def      UpperCAmelCase__					( self			:List[str] )    ->      List[Any]:
												UpperCAmelCase					=			TFMobileBertModelTest.TFMobileBertModelTester(self )
												UpperCAmelCase					=			ConfigTester(self       ,  config_class=lowercase_       ,  hidden_size=37 )






						def      UpperCAmelCase__					( self			:str )    ->      List[str]:
												self.config_tester.run_common_tests()






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[int]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_model(*lowercase_ )






						def      UpperCAmelCase__					( self			:List[str] )    ->      List[str]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_masked_lm(*lowercase_ )






						def      UpperCAmelCase__					( self			:Dict )    ->      Tuple:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_multiple_choice(*lowercase_ )






						def      UpperCAmelCase__					( self			:Tuple )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_next_sequence_prediction(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[int] )    ->      Optional[Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_pretraining(*lowercase_ )






						def      UpperCAmelCase__					( self			:List[Any] )    ->      Union[str, Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_question_answering(*lowercase_ )






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      Optional[Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_sequence_classification(*lowercase_ )






						def      UpperCAmelCase__					( self			:Dict )    ->      List[Any]:
												UpperCAmelCase					=			self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_mobilebert_for_token_classification(*lowercase_ )






						@slow
						def      UpperCAmelCase__					( self			:Union[str, Any] )    ->      str:
												# for model_name in TF_MOBILEBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												for model_name in ["google/mobilebert-uncased"]:
																		UpperCAmelCase					=			TFMobileBertModel.from_pretrained(lowercase_ )
																		self.assertIsNotNone(lowercase_ )







@require_tf
class 				A_      (					unittest.TestCase    ):



						"""simple docstring"""






						@slow
						def      UpperCAmelCase__					( self			:Optional[int] )    ->      Tuple:
												UpperCAmelCase					=			TFMobileBertForPreTraining.from_pretrained('google/mobilebert-uncased' )
												UpperCAmelCase					=			tf.constant([[0, 1, 2, 3, 4, 5]] )
												UpperCAmelCase					=			model(lowercase_ )[0]

												UpperCAmelCase					=			[1, 6, 3_05_22]
												self.assertEqual(output.shape       ,  lowercase_ )

												UpperCAmelCase					=			tf.constant(
												    [
												        [
												            [-4.591_9547, -9.24_8295, -9.64_5256],
												            [-6.730_6175, -6.44_0284, -6.605_2837],
												            [-7.274_3506, -6.784_7915, -6.02_4673],
												        ]
												    ] )
												tf.debugging.assert_near(output[:, :3, :3]       ,  lowercase_       ,  atol=1E-4 )










"""simple docstring"""


from collections import deque







class 				A_      :



						"""simple docstring"""






						def __init__( self			:Any       ,  lowercase_			:str       ,  lowercase_			:int       ,  lowercase_			:int )    ->      None:
												UpperCAmelCase					=			process_name  # process name
												UpperCAmelCase					=			arrival_time  # arrival time of the process
												# completion time of finished process or last interrupted time
												UpperCAmelCase					=			arrival_time
												UpperCAmelCase					=			burst_time  # remaining burst time
												UpperCAmelCase					=			0  # total time of the process wait in ready queue
												UpperCAmelCase					=			0  # time from arrival time to completion time







class 				A_      :



						"""simple docstring"""






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






						def      UpperCAmelCase__					( self			:Optional[int] )    ->      list[str]:
												UpperCAmelCase					=			[]
												for i in range(len(self.finish_queue ) ):
																		sequence.append(self.finish_queue[i].process_name )
												return sequence






						def      UpperCAmelCase__					( self			:List[str]       ,  lowercase_			:list[Process] )    ->      list[int]:
												UpperCAmelCase					=			[]
												for i in range(len(lowercase_ ) ):
																		waiting_times.append(queue[i].waiting_time )
												return waiting_times






						def      UpperCAmelCase__					( self			:List[str]       ,  lowercase_			:list[Process] )    ->      list[int]:
												UpperCAmelCase					=			[]
												for i in range(len(lowercase_ ) ):
																		turnaround_times.append(queue[i].turnaround_time )
												return turnaround_times






						def      UpperCAmelCase__					( self			:Dict       ,  lowercase_			:list[Process] )    ->      list[int]:
												UpperCAmelCase					=			[]
												for i in range(len(lowercase_ ) ):
																		completion_times.append(queue[i].stop_time )
												return completion_times






						def      UpperCAmelCase__					( self			:str       ,  lowercase_			:deque[Process] )    ->      list[int]:
												return [q.burst_time for q in queue]






						def      UpperCAmelCase__					( self			:int       ,  lowercase_			:Process )    ->      int:
												process.waiting_time += self.current_time - process.stop_time
												return process.waiting_time






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

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






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

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






						def      UpperCAmelCase__					( self			:Optional[Any] )    ->      deque[Process]:

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

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

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





