code: 
  
  
  """simple docstring"""
  
  
  
  
  from __future__ import annotations
  
  
  
  
  
  def 			a_   (  lowercase__   :list[int]    ):
  			if not list_of_ints:
  						return []
  
  			if min(lowercase__    ) < 0:
  						raise ValueError("""All numbers must be positive"""    )
  
  			__lowerCamelCase        =			max(len(bin(lowercase__    )[2:]    ) for x in list_of_ints    )
  			return _msd_radix_sort(lowercase__, lowercase__    )
  
  
  
  
  
  def 			a_   (  lowercase__   :list[int], lowercase__   :int    ):
  			if bit_position == 0 or len(lowercase__    ) in [0, 1]:
  						return list_of_ints
  
  			__lowerCamelCase        =			[]
  			__lowerCamelCase        =			[]
  			# Split numbers based on bit at bit_position from the right
  			for number in list_of_ints:
  						if (number >> (bit_position - 1)) & 1:
  									# number has a one at bit bit_position
  									ones.append(lowercase__    )
  						else:
  									# number has a zero at bit bit_position
  									zeros.append(lowercase__    )
  
      # recursively split both lists further
  			__lowerCamelCase        =			_msd_radix_sort(lowercase__, bit_position - 1    )
  			__lowerCamelCase        =			_msd_radix_sort(lowercase__, bit_position - 1    )
  
  			# recombine lists
  			__lowerCamelCase        =			zeros
  			res.extend(lowercase__    )
  
  			return res
  
  
  
  
  
  def 			a_   (  lowercase__   :list[int]    ):
  			__lowerCamelCase        =			len(lowercase__    )
  			if not list_of_ints or length == 1:
  						return
  
  			if min(lowercase__    ) < 0:
  						raise ValueError("""All numbers must be positive"""    )
  
  			__lowerCamelCase        =			max(len(bin(lowercase__    )[2:]    ) for x in list_of_ints    )
  			_msd_radix_sort_inplace(lowercase__, lowercase__, 0, lowercase__    )
  
  
  
  
  
  def 			a_   (  lowercase__   :list[int], lowercase__   :int, lowercase__   :int, lowercase__   :int    ):
  			if bit_position == 0 or end_index - begin_index <= 1:
  						return
  
  			bit_position -= 1
  
  			__lowerCamelCase        =			begin_index
  			__lowerCamelCase        =			end_index - 1
  			while i <= j:
  						__lowerCamelCase        =			False
  						if not (list_of_ints[i] >> bit_position) & 1:
  									# found zero at the beginning
  									i += 1
  									__lowerCamelCase        =			True
  						if (list_of_ints[j] >> bit_position) & 1:
  									# found one at the end
  									j -= 1
  									__lowerCamelCase        =			True
  
  						if changed:
  									continue
  
  						__lowerCamelCase    ,__lowerCamelCase        =			list_of_ints[j], list_of_ints[i]
  						j -= 1
  						if j != i:
  									i += 1
  
  			_msd_radix_sort_inplace(lowercase__, lowercase__, lowercase__, lowercase__    )
  			_msd_radix_sort_inplace(lowercase__, lowercase__, lowercase__, lowercase__    )
  
  
  if __name__ == "__main__":
  					import doctest
  
  					doctest.testmod()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  from typing import TYPE_CHECKING
  
  from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available
  
  
  __magic_name__	:   Optional[Any]          =							{
      'configuration_flaubert': ['FLAUBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'FlaubertConfig', 'FlaubertOnnxConfig'],
      'tokenization_flaubert': ['FlaubertTokenizer'],
  }
  
  try:
  					if not is_torch_available():
  										raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
  					pass
  else:
  					__magic_name__	:   List[Any]          =							[
  					    '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:
  					__magic_name__	:   Tuple          =							[
  					    '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
  
  					__magic_name__	:   List[str]          =							_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  