code: from __future__ import annotations
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	list		,						lowercase_:	list				):
         _UpperCamelCase     :       List[Any]  						=  [None] * (len(lowercase_				) + len(lowercase_				))
  
         _UpperCamelCase     :       Dict  						=  0  # pointer to current index for left Half
         _UpperCamelCase     :       str  						=  0  # pointer to current index for the right Half
         _UpperCamelCase     :       Any  						=  0  # pointer to current index for the sorted array Half
  
         while pointera < len(lowercase_				) and pointera < len(lowercase_				):
                if left_half[pointera] < right_half[pointera]:
                       _UpperCamelCase     :       Dict  						=  left_half[pointera]
                       pointera += 1
                       index += 1
                else:
                       _UpperCamelCase     :       Dict  						=  right_half[pointera]
                       pointera += 1
                       index += 1
         while pointera < len(lowercase_				):
                _UpperCamelCase     :       Dict  						=  left_half[pointera]
                pointera += 1
                index += 1
  
         while pointera < len(lowercase_				):
                _UpperCamelCase     :       List[Any]  						=  right_half[pointera]
                pointera += 1
                index += 1
  
         return sorted_array
  
  
  def SCREAMING_SNAKE_CASE				(     lowercase_:	list				):
         if len(lowercase_				) <= 1:
                return array
         # the actual formula to calculate the middle element = left + (right - left) // 2
         # this avoids integer overflow in case of large N
         _UpperCamelCase     :       Dict  						=  0 + (len(lowercase_				) - 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
         _UpperCamelCase     :       Optional[Any]  						=  array[:middle]
         _UpperCamelCase     :       List[str]  						=  array[middle:]
  
         return merge(merge_sort(lowercase_				)		,						merge_sort(lowercase_				)				)
  
  
  if __name__ == "__main__":
   import doctest
  
   doctest.testmod()
  
  
  
  
style_context: from ..utils import requires_backends
  
  
  UpperCAmelCase					=				None
  
  
  
  
  class    __lowerCAmelCase  :
  
  
  
   '''simple docstring'''
  
   def __init__(			self       :		Optional[int]       ,			*lowerCamelCase       :		Dict       ,			**lowerCamelCase       :		int  ) ->							Tuple:
          requires_backends(self       ,			['detectron2']  )
  
   @classmethod
   def 					__snake_case					(			cls       :		Optional[Any]       ,			*lowerCamelCase       :		Optional[int]       ,			**lowerCamelCase       :		Tuple  ) ->							List[str]:
          requires_backends(cls       ,			['detectron2']  )
  
  
  
  