"""simple docstring"""




import os
import tempfile
import unittest

from transformers import NezhaConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_torch_gpu, slow, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import (
				    MODEL_FOR_PRETRAINING_MAPPING,
				    NezhaForMaskedLM,
				    NezhaForMultipleChoice,
				    NezhaForNextSentencePrediction,
				    NezhaForPreTraining,
				    NezhaForQuestionAnswering,
				    NezhaForSequenceClassification,
				    NezhaForTokenClassification,
				    NezhaModel,
				)
				from transformers.models.nezha.modeling_nezha import NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST
class     UpperCamelCase__:





						def __init__(       self		,__UpperCAmelCase		,__UpperCAmelCase=13		,__UpperCAmelCase=7		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=True		,__UpperCAmelCase=99		,__UpperCAmelCase=32		,__UpperCAmelCase=5		,__UpperCAmelCase=4		,__UpperCAmelCase=37		,__UpperCAmelCase="gelu"		,__UpperCAmelCase=0.1		,__UpperCAmelCase=0.1		,__UpperCAmelCase=1_28		,__UpperCAmelCase=32		,__UpperCAmelCase=16		,__UpperCAmelCase=2		,__UpperCAmelCase=0.0_2		,__UpperCAmelCase=3		,__UpperCAmelCase=4		,__UpperCAmelCase=None		,)					->				Optional[Any]:
													A__	     =parent
													A__	     =batch_size
													A__	     =seq_length
													A__	     =is_training
													A__	     =use_input_mask
													A__	     =use_token_type_ids
													A__	     =use_labels
													A__	     =vocab_size
													A__	     =hidden_size
													A__	     =num_hidden_layers
													A__	     =num_attention_heads
													A__	     =intermediate_size
													A__	     =hidden_act
													A__	     =hidden_dropout_prob
													A__	     =attention_probs_dropout_prob
													A__	     =max_position_embeddings
													A__	     =type_vocab_size
													A__	     =type_sequence_label_size
													A__	     =initializer_range
													A__	     =num_labels
													A__	     =num_choices
													A__	     =scope





						def 				snake_case__	(       self     )					->				Optional[int]:
													A__	     =ids_tensor([self.batch_size, self.seq_length]		,self.vocab_size     )

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

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

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

													A__	     =self.get_config()

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





						def 				snake_case__	(       self     )					->				str:
													return NezhaConfig(
													    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		,is_decoder=lowerCAmelCase_		,initializer_range=self.initializer_range		,)





						def 				snake_case__	(       self     )					->				List[Any]:
													(
													    (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  						
													)	     =self.prepare_config_and_inputs()

													A__	     =True
													A__	     =floats_tensor([self.batch_size, self.seq_length, self.hidden_size]     )
													A__	     =ids_tensor([self.batch_size, self.seq_length]		,vocab_size=2     )

													return (
													    config,
													    input_ids,
													    token_type_ids,
													    input_mask,
													    sequence_labels,
													    token_labels,
													    choice_labels,
													    encoder_hidden_states,
													    encoder_attention_mask,
													)





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				int:
													A__	     =NezhaModel(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_     )
													A__	     =model(lowerCAmelCase_		,token_type_ids=lowerCAmelCase_     )
													A__	     =model(lowerCAmelCase_     )
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,)					->				int:
													A__	     =True
													A__	     =NezhaModel(lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(
													    lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,encoder_hidden_states=lowerCAmelCase_		,encoder_attention_mask=lowerCAmelCase_		,)
													A__	     =model(
													    lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,encoder_hidden_states=lowerCAmelCase_		,)
													A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_     )
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[int]:
													A__	     =NezhaForMaskedLM(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,labels=lowerCAmelCase_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.seq_length, self.vocab_size)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[Any]:
													A__	     =NezhaForNextSentencePrediction(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(
													    lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,labels=lowerCAmelCase_		,)
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, 2)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Optional[int]:
													A__	     =NezhaForPreTraining(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(
													    lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,labels=lowerCAmelCase_		,next_sentence_label=lowerCAmelCase_		,)
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Dict:
													A__	     =NezhaForQuestionAnswering(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(
													    lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,start_positions=lowerCAmelCase_		,end_positions=lowerCAmelCase_		,)
													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 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				List[Any]:
													A__	     =self.num_labels
													A__	     =NezhaForSequenceClassification(lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,labels=lowerCAmelCase_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_labels)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Tuple:
													A__	     =self.num_labels
													A__	     =NezhaForTokenClassification(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,labels=lowerCAmelCase_     )
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.seq_length, self.num_labels)     )





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase     )					->				Dict:
													A__	     =self.num_choices
													A__	     =NezhaForMultipleChoice(config=lowerCAmelCase_     )
													model.to(lowerCAmelCase_     )
													model.eval()
													A__	     =input_ids.unsqueeze(1     ).expand(-1		,self.num_choices		,-1     ).contiguous()
													A__	     =token_type_ids.unsqueeze(1     ).expand(-1		,self.num_choices		,-1     ).contiguous()
													A__	     =input_mask.unsqueeze(1     ).expand(-1		,self.num_choices		,-1     ).contiguous()
													A__	     =model(
													    lowerCAmelCase_		,attention_mask=lowerCAmelCase_		,token_type_ids=lowerCAmelCase_		,labels=lowerCAmelCase_		,)
													self.parent.assertEqual(result.logits.shape		,(self.batch_size, self.num_choices)     )





						def 				snake_case__	(       self     )					->				int:
													A__	     =self.prepare_config_and_inputs()
													(
													    (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  						
													)	     =config_and_inputs
													A__	     ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
													return config, inputs_dict






@require_torch
class     UpperCamelCase__(			__a		,						__a		,						__a		,						unittest.TestCase ):
						lowerCAmelCase__  :						List[Any]													=		(
						    (
						        NezhaModel,
						        NezhaForMaskedLM,
						        NezhaForMultipleChoice,
						        NezhaForNextSentencePrediction,
						        NezhaForPreTraining,
						        NezhaForQuestionAnswering,
						        NezhaForSequenceClassification,
						        NezhaForTokenClassification,
						    )
						    if is_torch_available()
						    else ()
						)
						lowerCAmelCase__  :						List[Any]													=		(
						    {
						        "feature-extraction": NezhaModel,
						        "fill-mask": NezhaForMaskedLM,
						        "question-answering": NezhaForQuestionAnswering,
						        "text-classification": NezhaForSequenceClassification,
						        "token-classification": NezhaForTokenClassification,
						        "zero-shot": NezhaForSequenceClassification,
						    }
						    if is_torch_available()
						    else {}
						)
						lowerCAmelCase__  :						List[str]													=		True





						def 				snake_case__	(       self		,__UpperCAmelCase		,__UpperCAmelCase		,__UpperCAmelCase=False     )					->				Optional[int]:
													A__	     =super()._prepare_for_class(lowerCAmelCase_		,lowerCAmelCase_		,return_labels=lowerCAmelCase_     )

													if return_labels:
																				if model_class in get_values(lowerCAmelCase_     ):
																											A__	     =torch.zeros(
																											    (self.model_tester.batch_size, self.model_tester.seq_length)		,dtype=torch.long		,device=lowerCAmelCase_     )
																											A__	     =torch.zeros(
																											    self.model_tester.batch_size		,dtype=torch.long		,device=lowerCAmelCase_     )
													return inputs_dict





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =NezhaModelTester(self     )
													A__	     =ConfigTester(self		,config_class=lowerCAmelCase_		,hidden_size=37     )





						def 				snake_case__	(       self     )					->				Union[str, Any]:
													self.config_tester.run_common_tests()





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				Tuple:
													A__	     =self.model_tester.prepare_config_and_inputs_for_decoder()
													self.model_tester.create_and_check_model_as_decoder(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				Dict:
													(
													    (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  (
													    A__						
													)     ,  						
													)	     =self.model_tester.prepare_config_and_inputs_for_decoder()

													A__	     =None

													self.model_tester.create_and_check_model_as_decoder(
													    lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,lowerCAmelCase_		,)





						def 				snake_case__	(       self     )					->				Optional[Any]:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_masked_lm(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				List[Any]:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_multiple_choice(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				str:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_next_sequence_prediction(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				Tuple:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_pretraining(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				int:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_question_answering(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				str:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_sequence_classification(*lowerCAmelCase_     )





						def 				snake_case__	(       self     )					->				Optional[int]:
													A__	     =self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_for_token_classification(*lowerCAmelCase_     )





						@slow
						def 				snake_case__	(       self     )					->				Optional[Any]:







													for model_name in NEZHA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																				A__	     =NezhaModel.from_pretrained(lowerCAmelCase_     )
																				self.assertIsNotNone(lowerCAmelCase_     )





						@slow
						@require_torch_gpu
						def 				snake_case__	(       self     )					->				List[str]:
													A__     ,  A__	     =self.model_tester.prepare_config_and_inputs_for_common()
													for model_class in self.all_model_classes:
																				# NezhaForMultipleChoice behaves incorrectly in JIT environments.
																				if model_class == NezhaForMultipleChoice:
																											return

																				A__	     =True
																				A__	     =model_class(config=lowerCAmelCase_     )

																				A__	     =self._prepare_for_class(lowerCAmelCase_		,lowerCAmelCase_     )
																				A__	     =torch.jit.trace(
																				    lowerCAmelCase_		,(inputs_dict['input_ids'].to('cpu'     ), inputs_dict['attention_mask'].to('cpu'     ))     )

																				with tempfile.TemporaryDirectory() as tmp:
																											torch.jit.save(lowerCAmelCase_		,os.path.join(lowerCAmelCase_		,'bert.pt'     )     )
																											A__	     =torch.jit.load(os.path.join(lowerCAmelCase_		,'bert.pt'     )		,map_location=lowerCAmelCase_     )
																											loaded(inputs_dict['input_ids'].to(lowerCAmelCase_     )		,inputs_dict['attention_mask'].to(lowerCAmelCase_     )     )






@require_torch
class     UpperCamelCase__(			unittest.TestCase ):





						@slow
						def 				snake_case__	(       self     )					->				str:
													A__	     =NezhaModel.from_pretrained('sijunhe/nezha-cn-base'     )
													A__	     =torch.tensor([[0, 1, 2, 3, 4, 5]]     )
													A__	     =torch.tensor([[0, 1, 1, 1, 1, 1]]     )
													with torch.no_grad():
																				A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_     )[0]
													A__	     =torch.Size((1, 6, 7_68)     )
													self.assertEqual(output.shape		,lowerCAmelCase_     )
													A__	     =torch.tensor([[[0.0_6_8_5, 0.2_4_4_1, 0.1_1_0_2], [0.0_6_0_0, 0.1_9_0_6, 0.1_3_4_9], [0.0_2_2_1, 0.0_8_1_9, 0.0_5_8_6]]]     )

													self.assertTrue(torch.allclose(output[:, 1:4, 1:4]		,lowerCAmelCase_		,atol=1e-4     )     )





						@slow
						def 				snake_case__	(       self     )					->				Tuple:
													A__	     =NezhaForMaskedLM.from_pretrained('sijunhe/nezha-cn-base'     )
													A__	     =torch.tensor([[0, 1, 2, 3, 4, 5]]     )
													A__	     =torch.tensor([[1, 1, 1, 1, 1, 1]]     )
													with torch.no_grad():
																				A__	     =model(lowerCAmelCase_		,attention_mask=lowerCAmelCase_     )[0]
													A__	     =torch.Size((1, 6, 2_11_28)     )
													self.assertEqual(output.shape		,lowerCAmelCase_     )
													A__	     =torch.tensor(
													    [[-2.7_9_3_9, -1.7_9_0_2, -2.2_1_8_9], [-2.8_5_8_5, -1.8_9_0_8, -2.3_7_2_3], [-2.6_4_9_9, -1.7_7_5_0, -2.2_5_5_8]]     )

													self.assertTrue(torch.allclose(output[:, 1:4, 1:4]		,lowerCAmelCase_		,atol=1e-4     )     )






"""simple docstring"""




from __future__ import annotations

import pandas as pd






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							A__	     =							[0] * no_of_processes
							A__	     =							[0] * no_of_processes
							# Copy the burst time into remaining_time[]
							for i in range(UpperCamelCase__				):
														A__	     =							burst_time[i]

							A__	     =							0
							A__	     =							0
							A__	     =							999_999_999
							A__	     =							0
							A__	     =							False

							# Process until all processes are completed
							while complete != no_of_processes:
														for j in range(UpperCamelCase__				):
																					if arrival_time[j] <= increment_time and remaining_time[j] > 0:
																												if remaining_time[j] < minm:
																																			A__	     =							remaining_time[j]
																																			A__	     =							j
																																			A__	     =							True

														if not check:
																					increment_time += 1
																					continue
														remaining_time[short] -= 1

														A__	     =							remaining_time[short]
														if minm == 0:
																					A__	     =							999_999_999

														if remaining_time[short] == 0:
																					complete += 1
																					A__	     =							False

																					# Find finish time of current process
																					A__	     =							increment_time + 1

																					# Calculate waiting time
																					A__	     =							finish_time - arrival_time[short]
																					A__	     =							finar - burst_time[short]

																					if waiting_time[short] < 0:
																												A__	     =							0

        # Increment time
														increment_time += 1
							return waiting_time






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							A__	     =							[0] * no_of_processes
							for i in range(UpperCamelCase__				):
														A__	     =							burst_time[i] + waiting_time[i]
							return turn_around_time






def   UpperCAmelCase					(	UpperCamelCase__       ,    UpperCamelCase__       ,    UpperCamelCase__				):






							"""simple docstring"""





							A__	     =							0
							A__	     =							0
							for i in range(UpperCamelCase__				):
														A__	     =							total_waiting_time + waiting_time[i]
														A__	     =							total_turn_around_time + turn_around_time[i]
							print(F'''Average waiting time = {total_waiting_time / no_of_processes:.5f}'''				)
							print('Average turn around time ='       ,    total_turn_around_time / no_of_processes				)


if __name__ == "__main__":
				print("Enter how many process you want to analyze")
				__lowerCamelCase											=  int(input())
				__lowerCamelCase											=  [0] * no_of_processes
				__lowerCamelCase											=  [0] * no_of_processes
				__lowerCamelCase											=  list(range(1, no_of_processes + 1))

				for i in range(no_of_processes):
								print("Enter the arrival time and burst time for process:--" + str(i + 1))
								__lowerCamelCase				,   __lowerCamelCase											=  map(int, input().split())

				__lowerCamelCase											=  calculate_waitingtime(arrival_time, burst_time, no_of_processes)

				__lowerCamelCase											=  burst_time
				__lowerCamelCase											=  no_of_processes
				__lowerCamelCase											=  waiting_time
				__lowerCamelCase											=  calculate_turnaroundtime(bt, n, wt)

				calculate_average_times(waiting_time, turn_around_time, no_of_processes)

				__lowerCamelCase											=  pd.DataFrame(
				    list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)),
				    columns=[
				        "Process",
				        "BurstTime",
				        "ArrivalTime",
				        "WaitingTime",
				        "TurnAroundTime",
				    ],
				)

				# Printing the dataFrame
				pd.set_option("display.max_rows", fcfs.shape[0] + 1)
				print(fcfs)





