code: 
  
  
  
  
  
  
  '''simple docstring'''
  
  
  
  
  
  from collections import OrderedDict
  from typing import Mapping
  
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfig
  from ...utils import logging
  
  
  lowerCamelCase										=  logging.get_logger(__name__)
  
  lowerCamelCase										=  {
      "flaubert/flaubert_small_cased": "https://huggingface.co/flaubert/flaubert_small_cased/resolve/main/config.json",
      "flaubert/flaubert_base_uncased": "https://huggingface.co/flaubert/flaubert_base_uncased/resolve/main/config.json",
      "flaubert/flaubert_base_cased": "https://huggingface.co/flaubert/flaubert_base_cased/resolve/main/config.json",
      "flaubert/flaubert_large_cased": "https://huggingface.co/flaubert/flaubert_large_cased/resolve/main/config.json",
  }
  
  class 					snake_case_							(       UpperCamelCase_      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     __lowerCAmelCase      =						"""flaubert"""
     __lowerCAmelCase      =						{
         """hidden_size""": """emb_dim""",
         """num_attention_heads""": """n_heads""",
         """num_hidden_layers""": """n_layers""",
         """n_words""": """vocab_size""",  # For backward compatibility
     }
  
     def __init__(    self:	str   ,       snake_case__:	Dict=False   ,       snake_case__:	List[Any]=0.0   ,       snake_case__:	List[Any]=30_145   ,       snake_case__:	Optional[Any]=2_048   ,       snake_case__:	Any=12   ,       snake_case__:	str=16   ,       snake_case__:	Dict=0.1   ,       snake_case__:	List[str]=0.1   ,       snake_case__:	str=True   ,       snake_case__:	Dict=False   ,       snake_case__:	Optional[Any]=False   ,       snake_case__:	Dict=False   ,       snake_case__:	Optional[Any]=1   ,       snake_case__:	List[Any]=True   ,       snake_case__:	List[Any]=512   ,       snake_case__:	int=2_048**-0.5   ,       snake_case__:	Any=1E-12   ,       snake_case__:	Any=0.02   ,       snake_case__:	Tuple=0   ,       snake_case__:	Any=1   ,       snake_case__:	List[str]=2   ,       snake_case__:	str=3   ,       snake_case__:	List[Any]=5   ,       snake_case__:	Dict=True   ,       snake_case__:	int="first"   ,       snake_case__:	List[Any]=True   ,       snake_case__:	Dict=None   ,       snake_case__:	str=True   ,       snake_case__:	Tuple=0.1   ,       snake_case__:	List[Any]=5   ,       snake_case__:	Dict=5   ,       snake_case__:	List[str]=0   ,       snake_case__:	List[str]=0   ,       snake_case__:	List[str]=2   ,       snake_case__:	int=0   ,       **snake_case__:	Optional[int]   ,       )  ->		Optional[int]:
  
  
         """simple docstring"""
  
  
  
         _lowercase     =	pre_norm
         _lowercase     =	layerdrop
         _lowercase     =	vocab_size
         _lowercase     =	emb_dim
         _lowercase     =	n_layers
         _lowercase     =	n_heads
         _lowercase     =	dropout
         _lowercase     =	attention_dropout
         _lowercase     =	gelu_activation
         _lowercase     =	sinusoidal_embeddings
         _lowercase     =	causal
         _lowercase     =	asm
         _lowercase     =	n_langs
         _lowercase     =	use_lang_emb
         _lowercase     =	layer_norm_eps
         _lowercase     =	bos_index
         _lowercase     =	eos_index
         _lowercase     =	pad_index
         _lowercase     =	unk_index
         _lowercase     =	mask_index
         _lowercase     =	is_encoder
         _lowercase     =	max_position_embeddings
         _lowercase     =	embed_init_std
         _lowercase     =	init_std
         _lowercase     =	summary_type
         _lowercase     =	summary_use_proj
         _lowercase     =	summary_activation
         _lowercase     =	summary_proj_to_labels
         _lowercase     =	summary_first_dropout
         _lowercase     =	start_n_top
         _lowercase     =	end_n_top
         _lowercase     =	mask_token_id
         _lowercase     =	lang_id
  
         if "n_words" in kwargs:
             _lowercase     =	kwargs['''n_words''']
  
         super().__init__(pad_token_id=__UpperCamelCase   ,       bos_token_id=__UpperCamelCase   ,       **__UpperCamelCase	)
  
  
  
  
  
  
  class 					snake_case_							(       UpperCamelCase_      ):
  
  
  
  
  
  
  
     """simple docstring"""
  
  
  
     @property
     def 			SCREAMING_SNAKE_CASE__				(    self:	Optional[Any]	)  ->		Mapping[str, Mapping[int, str]]:
  
  
         """simple docstring"""
  
  
  
         if self.task == "multiple-choice":
             _lowercase     =	{0: '''batch''', 1: '''choice''', 2: '''sequence'''}
         else:
             _lowercase     =	{0: '''batch''', 1: '''sequence'''}
         return OrderedDict(
             [
                 ('input_ids', dynamic_axis),
                 ('attention_mask', dynamic_axis),
             ]	)
  
style_context: 
  
  
  
  
  
  
  from __future__ import annotations
  def        UpperCAmelCase      (   _lowercase,      _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      _lowercase     =	[None] * (len(_lowercase      ) + len(_lowercase      ))
  
      _lowercase     =	0  # pointer to current index for left Half
      _lowercase     =	0  # pointer to current index for the right Half
      _lowercase     =	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]:
              _lowercase     =	left_half[pointera]
              pointera += 1
              index += 1
          else:
              _lowercase     =	right_half[pointera]
              pointera += 1
              index += 1
      while pointera < len(_lowercase      ):
          _lowercase     =	left_half[pointera]
          pointera += 1
          index += 1
  
      while pointera < len(_lowercase      ):
          _lowercase     =	right_half[pointera]
          pointera += 1
          index += 1
  
      return sorted_array
  def        UpperCAmelCase      (   _lowercase      ):
  
  
      '''simple docstring'''
  
  
  
      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
      _lowercase     =	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
      _lowercase     =	array[:middle]
      _lowercase     =	array[middle:]
  
      return merge(merge_sort(_lowercase      ),      merge_sort(_lowercase      )      )
  
  
  if __name__ == "__main__":
     import doctest
  
     doctest.testmod()
  