
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


_SCREAMING_SNAKE_CASE    :      str          =			{
    'configuration_albert': ['ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'AlbertConfig', 'AlbertOnnxConfig'],
}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Union[str, Any]          =			['AlbertTokenizer']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Optional[int]          =			['AlbertTokenizerFast']

try:
					if not is_torch_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Dict          =			[
					    'ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'AlbertForMaskedLM',
					    'AlbertForMultipleChoice',
					    'AlbertForPreTraining',
					    'AlbertForQuestionAnswering',
					    'AlbertForSequenceClassification',
					    'AlbertForTokenClassification',
					    'AlbertModel',
					    'AlbertPreTrainedModel',
					    'load_tf_weights_in_albert',
					]

try:
					if not is_tf_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      Any          =			[
					    'TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
					    'TFAlbertForMaskedLM',
					    'TFAlbertForMultipleChoice',
					    'TFAlbertForPreTraining',
					    'TFAlbertForQuestionAnswering',
					    'TFAlbertForSequenceClassification',
					    'TFAlbertForTokenClassification',
					    'TFAlbertMainLayer',
					    'TFAlbertModel',
					    'TFAlbertPreTrainedModel',
					]

try:
					if not is_flax_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					_SCREAMING_SNAKE_CASE    :      List[Any]          =			[
					    'FlaxAlbertForMaskedLM',
					    'FlaxAlbertForMultipleChoice',
					    'FlaxAlbertForPreTraining',
					    'FlaxAlbertForQuestionAnswering',
					    'FlaxAlbertForSequenceClassification',
					    'FlaxAlbertForTokenClassification',
					    'FlaxAlbertModel',
					    'FlaxAlbertPreTrainedModel',
					]

if TYPE_CHECKING:
					from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_albert import AlbertTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_albert_fast import AlbertTokenizerFast

					try:
										if not is_torch_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_albert import (
										    ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    AlbertForMaskedLM,
										    AlbertForMultipleChoice,
										    AlbertForPreTraining,
										    AlbertForQuestionAnswering,
										    AlbertForSequenceClassification,
										    AlbertForTokenClassification,
										    AlbertModel,
										    AlbertPreTrainedModel,
										    load_tf_weights_in_albert,
										)

					try:
										if not is_tf_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_tf_albert import (
										    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
										    TFAlbertForMaskedLM,
										    TFAlbertForMultipleChoice,
										    TFAlbertForPreTraining,
										    TFAlbertForQuestionAnswering,
										    TFAlbertForSequenceClassification,
										    TFAlbertForTokenClassification,
										    TFAlbertMainLayer,
										    TFAlbertModel,
										    TFAlbertPreTrainedModel,
										)

					try:
										if not is_flax_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .modeling_flax_albert import (
										    FlaxAlbertForMaskedLM,
										    FlaxAlbertForMultipleChoice,
										    FlaxAlbertForPreTraining,
										    FlaxAlbertForQuestionAnswering,
										    FlaxAlbertForSequenceClassification,
										    FlaxAlbertForTokenClassification,
										    FlaxAlbertModel,
										    FlaxAlbertPreTrainedModel,
										)
else:
					import sys

					_SCREAMING_SNAKE_CASE    :      Union[str, Any]          =			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)







def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						int       ) ->       List[Any]:

				"""simple docstring"""







				A__  :	Optional[Any]         =							0
				A__  :	Optional[Any]         =							len(__UpperCamelCase       )

				for i in range(n - 1       ):
								for j in range(i + 1							,						__UpperCamelCase       ):
												if arr[i] > arr[j]:
																num_inversions += 1

				return num_inversions

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						int       ) ->       Tuple:

				"""simple docstring"""







				if len(__UpperCamelCase       ) <= 1:
								return arr, 0
				A__  :	Optional[int]         =							len(__UpperCamelCase       ) // 2
				A__  :	List[str]         =							arr[0:mid]
				A__  :	Union[str, Any]         =							arr[mid:]

				A__       ,							A__  :	List[Any]         =							count_inversions_recursive(__UpperCamelCase       )
				A__       ,							A__  :	int         =							count_inversions_recursive(__UpperCamelCase       )
				A__       ,							A__  :	Dict         =							_count_cross_inversions(__UpperCamelCase							,						__UpperCamelCase       )

				A__  :	Any         =							inversion_p + inversions_q + cross_inversions
				return c, num_inversions

def 				SCREAMING_SNAKE_CASE     (      __UpperCamelCase :						List[str]							,						__UpperCamelCase :						List[Any]       ) ->       Dict:

				"""simple docstring"""







				A__  :	str         =							[]
				A__  :	Tuple         =							0
				while i < len(__UpperCamelCase       ) and j < len(__UpperCamelCase       ):
								if p[i] > q[j]:
												# if P[1] > Q[j], then P[k] > Q[k] for all  i < k <= len(P)
												# These are all inversions. The claim emerges from the
												# property that P is sorted.
												num_inversion += len(__UpperCamelCase       ) - i
												r.append(q[j]       )
												j += 1
								else:
												r.append(p[i]       )
												i += 1

				if i < len(__UpperCamelCase       ):
								r.extend(p[i:]       )
				else:
								r.extend(q[j:]       )

				return r, num_inversion

def 				SCREAMING_SNAKE_CASE     (      ) ->       Tuple:

				"""simple docstring"""







				A__  :	List[str]         =							[10, 2, 1, 5, 5, 2, 11]

				# this arr has 8 inversions:
				# (10, 2), (10, 1), (10, 5), (10, 5), (10, 2), (2, 1), (5, 2), (5, 2)

				A__  :	int         =							count_inversions_bf(__UpperCamelCase       )
				A__       ,							A__  :	int         =							count_inversions_recursive(__UpperCamelCase       )

				assert num_inversions_bf == num_inversions_recursive == 8

				print('''number of inversions = '''							,						__UpperCamelCase       )

				# testing an array with zero inversion (a sorted arr_1)

				arr_a.sort()
				A__  :	Optional[Any]         =							count_inversions_bf(__UpperCamelCase       )
				A__       ,							A__  :	Dict         =							count_inversions_recursive(__UpperCamelCase       )

				assert num_inversions_bf == num_inversions_recursive == 0
				print('''number of inversions = '''							,						__UpperCamelCase       )

				# an empty list should also have zero inversions
				A__  :	Union[str, Any]         =							[]
				A__  :	Union[str, Any]         =							count_inversions_bf(__UpperCamelCase       )
				A__       ,							A__  :	Any         =							count_inversions_recursive(__UpperCamelCase       )

				assert num_inversions_bf == num_inversions_recursive == 0
				print('''number of inversions = '''							,						__UpperCamelCase       )


if __name__ == "__main__":
					main()