



'''simple docstring'''



def 							__UpperCAmelCase				(				UpperCamelCase__				:Any   ,				UpperCamelCase__				:Optional[int]			)		->						Tuple:
				if len(str(UpperCamelCase__			)			) == 1 or len(str(UpperCamelCase__			)			) == 1:
								return a * b

				snake_case__      :   List[str]      =    max(len(str(UpperCamelCase__			)			)   ,				len(str(UpperCamelCase__			)			)			)
				snake_case__      :   Union[str, Any]      =    ma // 2

				snake_case__  ,      snake_case__      :   Any      =    divmod(UpperCamelCase__   ,				10**ma			)
				snake_case__  ,      snake_case__      :   int      =    divmod(UpperCamelCase__   ,				10**ma			)

				snake_case__      :   Tuple      =    karatsuba(UpperCamelCase__   ,				UpperCamelCase__			)
				snake_case__      :   Any      =    karatsuba((aa + aa)   ,				(ba + ba)			)
				snake_case__      :   Union[str, Any]      =    karatsuba(UpperCamelCase__   ,				UpperCamelCase__			)

				return (z * 10 ** (2 * ma)) + ((y - z - x) * 10 ** (ma)) + (x)


def 							__UpperCAmelCase				(				)		->						int:
				print(karatsuba(1_5463   ,				2_3489			)			)


if __name__ == "__main__":
				main()





from __future__ import annotations

from statistics import mean


def SCREAMING_SNAKE_CASE					(  lowercase_:						list[int]					):
       _UpperCamelCase  :							str	    =	2
       _UpperCamelCase  :							Optional[int]	    =	list(lowercase_					)
       _UpperCamelCase  :							Union[str, Any]	    =	[0] * len(lowercase_					)
       _UpperCamelCase  :							List[str]	    =	0
       while True:
              _UpperCamelCase  :							List[str]	    =	True
              for i, burst_time in enumerate(lowercase_					):
                     if rem_burst_times[i] > 0:
                            _UpperCamelCase  :							List[str]	    =	False
                            if rem_burst_times[i] > quantum:
                                   t += quantum
                                   rem_burst_times[i] -= quantum
                            else:
                                   t += rem_burst_times[i]
                                   _UpperCamelCase  :							str	    =	t - burst_time
                                   _UpperCamelCase  :							Union[str, Any]	    =	0
              if done is True:
                     return waiting_times


def SCREAMING_SNAKE_CASE					(  lowercase_:						list[int]		,    lowercase_:						list[int]					):
       return [burst + waiting for burst, waiting in zip(lowercase_		,    lowercase_					)]


if __name__ == "__main__":
 UpperCAmelCase      		=					[3, 5, 7]
 UpperCAmelCase      		=					calculate_waiting_times(burst_times)
 UpperCAmelCase      		=					calculate_turn_around_times(burst_times, waiting_times)
 print('''Process ID \tBurst Time \tWaiting Time \tTurnaround Time''')
 for i, burst_time in enumerate(burst_times):
  print(
      f'''  {i + 1}\t\t  {burst_time}\t\t  {waiting_times[i]}\t\t  '''
      f'''{turn_around_times[i]}'''
  )
 print(f'''\nAverage waiting time = {mean(waiting_times):.5f}''')
 print(f'''Average turn around time = {mean(turn_around_times):.5f}''')



