




from __future__ import annotations

from math import pi

# Define the Reduced Planck Constant ℏ (H bar), speed of light C, value of
# Pi and the function
UpperCamelCase								=	1.0_5457_1817E-34  # unit of ℏ : J * s

UpperCamelCase								=	3E8  # unit of c : m * s^-1



def 				_A  (		lowerCAmelCase_	:   float  ,							lowerCAmelCase_	:   float  ,							lowerCAmelCase_	:   float     ):
     """simple docstring"""

     if (force, area, distance).count(0     ) != 1:
          raise ValueError("One and only one argument must be 0"     )
     if force < 0:
          raise ValueError("Magnitude of force can not be negative"     )
     if distance < 0:
          raise ValueError("Distance can not be negative"     )
     if area < 0:
          raise ValueError("Area can not be negative"     )
     if force == 0:
          lowerCAmelCase__            =					(REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (
              240 * (distance) ** 4
          )
          return {"force": force}
     elif area == 0:
          lowerCAmelCase__            =					(240 * force * (distance) ** 4) / (
              REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2
          )
          return {"area": area}
     elif distance == 0:
          lowerCAmelCase__            =					(
              (REDUCED_PLANCK_CONSTANT * SPEED_OF_LIGHT * pi**2 * area) / (240 * force)
          ) ** (1 / 4)
          return {"distance": distance}
     raise ValueError("One and only one argument must be 0"     )


# Run doctest
if __name__ == "__main__":
     import doctest

     doctest.testmod()




'''simple docstring'''






from __future__ import annotations







def 							UpperCamelCase_     (       A__   :  list				,       A__   :  int				,       A__   :  int				,       A__   :  int   ):
  '''simple docstring'''





  lowerCAmelCase_     : int     =  []
  lowerCAmelCase_,				lowerCAmelCase_     : Any     =  input_list[low:mid], input_list[mid : high + 1]
  while left and right:
    result.append((left if left[0] <= right[0] else right).pop(0   )   )
  lowerCAmelCase_     : Dict     =  result + left + right
  return input_list







def 							UpperCamelCase_     (       A__   :  list   ):
  '''simple docstring'''





  if len(A__   ) <= 1:
    return input_list
  lowerCAmelCase_     : str     =  list(A__   )

  # iteration for two-way merging
  lowerCAmelCase_     : Dict     =  2
  while p <= len(A__   ):
    # getting low, high and middle value for merge-sort of single list
    for i in range(0				,       len(A__   )				,       A__   ):
      lowerCAmelCase_     : Tuple     =  i
      lowerCAmelCase_     : List[str]     =  i + p - 1
      lowerCAmelCase_     : Optional[Any]     =  (low + high + 1) // 2
      lowerCAmelCase_     : List[str]     =  merge(A__				,       A__				,       A__				,       A__   )
    # final merge of last two parts
    if p * 2 >= len(A__   ):
      lowerCAmelCase_     : Union[str, Any]     =  i
      lowerCAmelCase_     : Dict     =  merge(A__				,       0				,       A__				,       len(A__   ) - 1   )
      break
    p *= 2

  return input_list


if __name__ == "__main__":
  __A   :    int											= input("Enter numbers separated by a comma:\n").strip()
  if user_input == "":
    __A   :    str											= []
  else:
    __A   :    Optional[Any]											= [int(item.strip()) for item in user_input.split(",")]
  print(iter_merge_sort(unsorted))



