code: 
  
  
  
  
  
  from __future__ import annotations
  
  
  
  
  def       a__						(		snake_case__				:       list	,      snake_case__				:       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       a__						(		snake_case__				:       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 typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
  
  
  SCREAMING_SNAKE_CASE__				:    List[str]         =    {
      'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
      'tokenization_flaubert': ['FlaubertTokenizer'],
  }
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   SCREAMING_SNAKE_CASE__				:    int         =    [
       'FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'FlaubertForMultipleChoice',
       'FlaubertForQuestionAnswering',
       'FlaubertForQuestionAnsweringSimple',
       'FlaubertForSequenceClassification',
       'FlaubertForTokenClassification',
       'FlaubertModel',
       'FlaubertWithLMHeadModel',
       'FlaubertPreTrainedModel',
   ]
  
  try:
   if not is_tf_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   SCREAMING_SNAKE_CASE__				:    Dict         =    [
       'TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
       'TFFlaubertForMultipleChoice',
       'TFFlaubertForQuestionAnsweringSimple',
       'TFFlaubertForSequenceClassification',
       'TFFlaubertForTokenClassification',
       'TFFlaubertModel',
       'TFFlaubertPreTrainedModel',
       'TFFlaubertWithLMHeadModel',
   ]
  
  
  if TYPE_CHECKING:
   from .configuration_flaubert import FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, FlaubertConfig, FlaubertOnnxConfig
   from .tokenization_flaubert import FlaubertTokenizer
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_flaubert import (
        FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        FlaubertForMultipleChoice,
        FlaubertForQuestionAnswering,
        FlaubertForQuestionAnsweringSimple,
        FlaubertForSequenceClassification,
        FlaubertForTokenClassification,
        FlaubertModel,
        FlaubertPreTrainedModel,
        FlaubertWithLMHeadModel,
    )
  
   try:
    if not is_tf_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_tf_flaubert import (
        TF_FLAUBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TFFlaubertForMultipleChoice,
        TFFlaubertForQuestionAnsweringSimple,
        TFFlaubertForSequenceClassification,
        TFFlaubertForTokenClassification,
        TFFlaubertModel,
        TFFlaubertPreTrainedModel,
        TFFlaubertWithLMHeadModel,
    )
  
  else:
   import sys
  
   SCREAMING_SNAKE_CASE__				:    List[Any]         =    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  
  