code: 
  
  
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase   ,       __lowerCamelCase					)   -> list:
  
       '''simple docstring'''
       UpperCAmelCase__			:     List[str]										= [None] * (len(__lowerCamelCase					) + len(__lowerCamelCase					))
  
       UpperCAmelCase__			:     str										= 0  # pointer to current index for left Half
       UpperCAmelCase__			:     List[Any]										= 0  # pointer to current index for the right Half
       UpperCAmelCase__			:     str										= 0  # pointer to current index for the sorted array Half
  
       while pointera < len(__lowerCamelCase					) and pointera < len(__lowerCamelCase					):
            if left_half[pointera] < right_half[pointera]:
                 UpperCAmelCase__			:     int										= left_half[pointera]
                 pointera += 1
                 index += 1
            else:
                 UpperCAmelCase__			:     Any										= right_half[pointera]
                 pointera += 1
                 index += 1
       while pointera < len(__lowerCamelCase					):
            UpperCAmelCase__			:     int										= left_half[pointera]
            pointera += 1
            index += 1
  
       while pointera < len(__lowerCamelCase					):
            UpperCAmelCase__			:     Union[str, Any]										= right_half[pointera]
            pointera += 1
            index += 1
  
       return sorted_array
  
  
  
  
  
  def    _lowerCamelCase	(	__lowerCamelCase					)   -> list:
  
       '''simple docstring'''
       if len(__lowerCamelCase					) <= 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__			:     Union[str, Any]										= 0 + (len(__lowerCamelCase					) - 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__			:     Optional[int]										= array[middle:]
  
       return merge(merge_sort(__lowerCamelCase					)   ,       merge_sort(__lowerCamelCase					)					)
  
  
  if __name__ == "__main__":
        import doctest
  
        doctest.testmod()
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available
  
  
  SCREAMING_SNAKE_CASE__		:       Any   							=							{"""configuration_dinat""": ["""DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP""", """DinatConfig"""]}
  
  
  try:
        if not is_torch_available():
              raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
        pass
  else:
        SCREAMING_SNAKE_CASE__		:       str   							=							[
            """DINAT_PRETRAINED_MODEL_ARCHIVE_LIST""",
            """DinatForImageClassification""",
            """DinatModel""",
            """DinatPreTrainedModel""",
            """DinatBackbone""",
        ]
  
  if TYPE_CHECKING:
        from .configuration_dinat import DINAT_PRETRAINED_CONFIG_ARCHIVE_MAP, DinatConfig
  
        try:
              if not is_torch_available():
                    raise OptionalDependencyNotAvailable()
        except OptionalDependencyNotAvailable:
              pass
        else:
              from .modeling_dinat import (
                  DINAT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DinatBackbone,
                  DinatForImageClassification,
                  DinatModel,
                  DinatPreTrainedModel,
              )
  
  else:
        import sys
  
        SCREAMING_SNAKE_CASE__		:       Dict   							=							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)
  
  
  
  
  
  
  