


'''simple docstring'''







def _UpperCamelCase	(					__A   )							->		Optional[Any]:


						'''simple docstring'''



						if len(lowerCamelCase_   ) > 1:
												UpperCamelCase__  =    len(lowerCamelCase_   ) // 2  # Finds the middle of the array
												UpperCamelCase__  =    arr[
												    :middle_length
												]  # Creates an array of the elements in the first half.
												UpperCamelCase__  =    arr[
												    middle_length:
												]  # Creates an array of the elements in the second half.
												UpperCamelCase__  =    len(lowerCamelCase_   )
												UpperCamelCase__  =    len(lowerCamelCase_   )
												merge(lowerCamelCase_   )  # Starts sorting the left.
												merge(lowerCamelCase_   )  # Starts sorting the right
												UpperCamelCase__  =    0  # Left Counter
												UpperCamelCase__  =    0  # Right Counter
												UpperCamelCase__  =    0  # Position Counter
												while (
												    left_index < left_size and right_index < right_size
												):  # Runs until the lowers size of the left and right are sorted.
																		if left_array[left_index] < right_array[right_index]:
																								UpperCamelCase__  =    left_array[left_index]
																								left_index += 1
																		else:
																								UpperCamelCase__  =    right_array[right_index]
																								right_index += 1
																		index += 1
												while (
												    left_index < left_size
												):  # Adds the left over elements in the left half of the array
																		UpperCamelCase__  =    left_array[left_index]
																		left_index += 1
																		index += 1
												while (
												    right_index < right_size
												):  # Adds the left over elements in the right half of the array
																		UpperCamelCase__  =    right_array[right_index]
																		right_index += 1
																		index += 1
						return arr


if __name__ == "__main__":
		import doctest

		doctest.testmod()









'''simple docstring'''







# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
    is_vision_available,
)


a__  : Any				=	{
    'configuration_tvlt': ['TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'TvltConfig'],
    'feature_extraction_tvlt': ['TvltFeatureExtractor'],
    'processing_tvlt': ['TvltProcessor'],
}

try:
  if not is_torch_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  : int				=	[
      'TVLT_PRETRAINED_MODEL_ARCHIVE_LIST',
      'TvltModel',
      'TvltForPreTraining',
      'TvltForAudioVisualClassification',
      'TvltPreTrainedModel',
  ]

try:
  if not is_vision_available():
    raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
  pass
else:
  a__  : List[Any]				=	['TvltImageProcessor']


if TYPE_CHECKING:
  from .configuration_tvlt import TVLT_PRETRAINED_CONFIG_ARCHIVE_MAP, TvltConfig
  from .processing_tvlt import TvltProcessor
  from .feature_extraction_tvlt import TvltFeatureExtractor

  try:
    if not is_torch_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .modeling_tvlt import (
        TVLT_PRETRAINED_MODEL_ARCHIVE_LIST,
        TvltForAudioVisualClassification,
        TvltForPreTraining,
        TvltModel,
        TvltPreTrainedModel,
    )

  try:
    if not is_vision_available():
      raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
    pass
  else:
    from .image_processing_tvlt import TvltImageProcessor


else:
  import sys

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





