




"""simple docstring"""
import os
import string
import sys


a_				:    int										=     1 << 8

a_				:    Tuple										=     {
    '''tab''': ord('''\t'''),
    '''newline''': ord('''\r'''),
    '''esc''': 27,
    '''up''': 65 + ARROW_KEY_FLAG,
    '''down''': 66 + ARROW_KEY_FLAG,
    '''right''': 67 + ARROW_KEY_FLAG,
    '''left''': 68 + ARROW_KEY_FLAG,
    '''mod_int''': 91,
    '''undefined''': sys.maxsize,
    '''interrupt''': 3,
    '''insert''': 50,
    '''delete''': 51,
    '''pg_up''': 53,
    '''pg_down''': 54,
}

a_				:    List[str]										=     KEYMAP['''up''']
a_				:    Dict										=     KEYMAP['''left''']

if sys.platform == "win32":
					a_				:    List[str]										=     []
					a_				:    Dict										=     {
					    b'''\xe0H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
					    b'''\x00H''': KEYMAP['''up'''] - ARROW_KEY_FLAG,
					    b'''\xe0P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
					    b'''\x00P''': KEYMAP['''down'''] - ARROW_KEY_FLAG,
					    b'''\xe0M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
					    b'''\x00M''': KEYMAP['''right'''] - ARROW_KEY_FLAG,
					    b'''\xe0K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
					    b'''\x00K''': KEYMAP['''left'''] - ARROW_KEY_FLAG,
					}

for i in range(10):
					a_				:    Tuple										=     ord(str(i))





def 						UpperCAmelCase				(			)  ->     Union[str, Any]:
			if os.name == "nt":
						import msvcrt

						__lowerCamelCase					:	Union[str, Any]	       =				'mbcs'
						# Flush the keyboard buffer
						while msvcrt.kbhit():
									msvcrt.getch()
						if len(A__     ) == 0:
									# Read the keystroke
									__lowerCamelCase					:	Any	       =				msvcrt.getch()

									# If it is a prefix char, get second part
									if ch in (b"\x00", b"\xe0"):
												__lowerCamelCase					:	Optional[Any]	       =				ch + msvcrt.getch()
												# Translate actual Win chars to bullet char types
												try:
															__lowerCamelCase					:	Optional[int]	       =				chr(WIN_KEYMAP[cha]     )
															WIN_CH_BUFFER.append(chr(KEYMAP['mod_int']     )     )
															WIN_CH_BUFFER.append(A__     )
															if ord(A__     ) in (
															    KEYMAP["insert"] - 1 << 9,
															    KEYMAP["delete"] - 1 << 9,
															    KEYMAP["pg_up"] - 1 << 9,
															    KEYMAP["pg_down"] - 1 << 9,
															):
																		WIN_CH_BUFFER.append(chr(126     )     )
															__lowerCamelCase					:	Tuple	       =				chr(KEYMAP['esc']     )
												except KeyError:
															__lowerCamelCase					:	List[Any]	       =				cha[1]
									else:
												__lowerCamelCase					:	str	       =				ch.decode(A__     )
						else:
									__lowerCamelCase					:	Any	       =				WIN_CH_BUFFER.pop(0     )
			elif os.name == "posix":
						import termios
						import tty

						__lowerCamelCase					:	Tuple	       =				sys.stdin.fileno()
						__lowerCamelCase					:	Union[str, Any]	       =				termios.tcgetattr(A__     )
						try:
									tty.setraw(A__     )
									__lowerCamelCase					:	str	       =				sys.stdin.read(1     )
						finally:
									termios.tcsetattr(A__							,				termios.TCSADRAIN							,				A__     )
			return ch






def 						UpperCAmelCase				(			)  ->     str:
			__lowerCamelCase					:	Optional[Any]	       =				get_raw_chars()
			if ord(A__     ) in [KEYMAP["interrupt"], KEYMAP["newline"]]:
						return char

			elif ord(A__     ) == KEYMAP["esc"]:
						__lowerCamelCase					:	Dict	       =				get_raw_chars()
						if ord(A__     ) == KEYMAP["mod_int"]:
									__lowerCamelCase					:	List[str]	       =				get_raw_chars()
									if ord(A__     ) >= KEYMAP["arrow_begin"] - ARROW_KEY_FLAG and ord(A__     ) <= KEYMAP["arrow_end"] - ARROW_KEY_FLAG:
												return chr(ord(A__     ) + ARROW_KEY_FLAG     )
									else:
												return KEYMAP["undefined"]
						else:
									return get_raw_chars()

			else:
						if char in string.printable:
									return char
						else:
									return KEYMAP["undefined"]









"""simple docstring"""
from __future__ import annotations

import pandas as pd





def 						UpperCAmelCase				(			A__:    list[int]							,				A__:    list[int]							,				A__:    int     )  ->     list[int]:
			__lowerCamelCase					:	List[Any]	       =				[0] * no_of_processes
			__lowerCamelCase					:	Any	       =				[0] * no_of_processes
			# Copy the burst time into remaining_time[]
			for i in range(A__     ):
						__lowerCamelCase					:	Dict	       =				burst_time[i]

			__lowerCamelCase					:	Any	       =				0
			__lowerCamelCase					:	Tuple	       =				0
			__lowerCamelCase					:	Union[str, Any]	       =				999999999
			__lowerCamelCase					:	str	       =				0
			__lowerCamelCase					:	Optional[int]	       =				False

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

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

						__lowerCamelCase					:	Optional[Any]	       =				remaining_time[short]
						if minm == 0:
									__lowerCamelCase					:	Optional[int]	       =				999999999

						if remaining_time[short] == 0:
									complete += 1
									__lowerCamelCase					:	List[str]	       =				False

									# Find finish time of current process
									__lowerCamelCase					:	Dict	       =				increment_time + 1

									# Calculate waiting time
									__lowerCamelCase					:	Any	       =				finish_time - arrival_time[short]
									__lowerCamelCase					:	Dict	       =				finar - burst_time[short]

									if waiting_time[short] < 0:
												__lowerCamelCase					:	Optional[Any]	       =				0

        # Increment time
						increment_time += 1
			return waiting_time





def 						UpperCAmelCase				(			A__:    list[int]							,				A__:    int							,				A__:    list[int]     )  ->     list[int]:
			__lowerCamelCase					:	List[Any]	       =				[0] * no_of_processes
			for i in range(A__     ):
						__lowerCamelCase					:	Tuple	       =				burst_time[i] + waiting_time[i]
			return turn_around_time





def 						UpperCAmelCase				(			A__:    list[int]							,				A__:    list[int]							,				A__:    int     )  ->     None:
			__lowerCamelCase					:	int	       =				0
			__lowerCamelCase					:	Dict	       =				0
			for i in range(A__     ):
						__lowerCamelCase					:	str	       =				total_waiting_time + waiting_time[i]
						__lowerCamelCase					:	Union[str, Any]	       =				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''')
					a_				:    int										=     int(input())
					a_				:    List[str]										=     [0] * no_of_processes
					a_				:    int										=     [0] * no_of_processes
					a_				:    int										=     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))
										a_						,							a_				:    Union[str, Any]										=     map(int, input().split())

					a_				:    Any										=     calculate_waitingtime(arrival_time, burst_time, no_of_processes)

					a_				:    List[str]										=     burst_time
					a_				:    List[Any]										=     no_of_processes
					a_				:    Tuple										=     waiting_time
					a_				:    Optional[Any]										=     calculate_turnaroundtime(bt, n, wt)

					calculate_average_times(waiting_time, turn_around_time, no_of_processes)

					a_				:    List[Any]										=     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)



