'''simple docstring'''




from __future__ import annotations

from enum import Enum, unique
from typing import TypeVar

# Create a generic variable that can be 'Enum', or any subclass.
__UpperCAmelCase  							=    TypeVar("T", bound="Enum")




@unique
class 					a__   (     UpperCamelCase_				):
     lowerCamelCase						:  Any							=8_0
     lowerCamelCase						:  Union[str, Any]							=7_0
     lowerCamelCase						:  List[str]							=6_0
     lowerCamelCase						:  Dict							=5_0
     lowerCamelCase						:  Any							=4_0
     lowerCamelCase						:  int							=3_0
     lowerCamelCase						:  Optional[Any]							=2_0
     lowerCamelCase						:  Optional[int]							=1_0




@unique
class 					a__   (     UpperCamelCase_				):
     lowerCamelCase						:  Optional[int]							=2_4
     lowerCamelCase						:  Dict							=2_1
     lowerCamelCase						:  Dict							=1_8
     lowerCamelCase						:  Optional[int]							=1_5
     lowerCamelCase						:  Any							=1_2
     lowerCamelCase						:  Tuple							=9
     lowerCamelCase						:  List[str]							=6
     lowerCamelCase						:  str							=3
     lowerCamelCase						:  Optional[Any]							=2
     lowerCamelCase						:  int							=1
     lowerCamelCase						:  Optional[int]							=-1
     lowerCamelCase						:  Dict							=-2
     lowerCamelCase						:  Optional[Any]							=-3
     lowerCamelCase						:  Dict							=-6
     lowerCamelCase						:  List[str]							=-9
     lowerCamelCase						:  str							=-1_2
     lowerCamelCase						:  Any							=-1_5
     lowerCamelCase						:  str							=-1_8
     lowerCamelCase						:  Dict							=-2_1
     lowerCamelCase						:  Optional[int]							=-2_4






     @classmethod
     def      SCREAMING_SNAKE_CASE__     (				cls	:	Dict					):





         """simple docstring"""



         return {unit.name: unit.value for unit in cls if unit.value > 0}






     @classmethod
     def      SCREAMING_SNAKE_CASE__     (				cls	:	Optional[int]					):





         """simple docstring"""



         return {unit.name: unit.value for unit in cls if unit.value < 0}






def __lowerCAmelCase				(							UpperCamelCase__       )			->					str:
    __lowerCamelCase						=						SIUnit.get_positive() if value > 0 else SIUnit.get_negative()
    for name_prefix, value_prefix in prefixes.items():
        __lowerCamelCase						=						value / (10**value_prefix)
        if numerical_part > 1:
            return f"""{numerical_part!s} {name_prefix}"""
    return str(snake_case__       )






def __lowerCAmelCase				(							UpperCamelCase__       )			->					str:
    for prefix in BinaryUnit:
        __lowerCamelCase						=						value / (2**prefix.value)
        if numerical_part > 1:
            return f"""{numerical_part!s} {prefix.name}"""
    return str(snake_case__       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()

'''simple docstring'''




from __future__ import annotations






def __lowerCAmelCase				(							UpperCamelCase__       ,						UpperCamelCase__       )			->					list:
    __lowerCamelCase						=						[None] * (len(UpperCamelCase__       ) + len(UpperCamelCase__       ))

    __lowerCamelCase						=						0  # pointer to current index for left Half
    __lowerCamelCase						=						0  # pointer to current index for the right Half
    __lowerCamelCase						=						0  # pointer to current index for the sorted array Half

    while pointera < len(UpperCamelCase__       ) and pointera < len(UpperCamelCase__       ):
        if left_half[pointera] < right_half[pointera]:
            __lowerCamelCase						=						left_half[pointera]
            pointera += 1
            index += 1
        else:
            __lowerCamelCase						=						right_half[pointera]
            pointera += 1
            index += 1
    while pointera < len(UpperCamelCase__       ):
        __lowerCamelCase						=						left_half[pointera]
        pointera += 1
        index += 1

    while pointera < len(UpperCamelCase__       ):
        __lowerCamelCase						=						right_half[pointera]
        pointera += 1
        index += 1

    return sorted_array






def __lowerCAmelCase				(							UpperCamelCase__       )			->					list:
    if len(UpperCamelCase__       ) <= 1:
        return array
    # the actual formula to calculate the middle element = left + (right - left) // 2
    # this avoids integer overflow in case of large N
    __lowerCamelCase						=						0 + (len(UpperCamelCase__       ) - 0) // 2

    # Split the array into halves till the array length becomes equal to One
    # merge the arrays of single length returned by mergeSort function and
    # pass them into the merge arrays function which merges the array
    __lowerCamelCase						=						array[:middle]
    __lowerCamelCase						=						array[middle:]

    return merge(merge_sort(UpperCamelCase__       )       ,						merge_sort(UpperCamelCase__       )       )


if __name__ == "__main__":
  import doctest

  doctest.testmod()
