"""simple docstring"""







def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	if len(__UpperCAmelCase			) <= 1:
		return [tuple(__UpperCAmelCase			)]

	_lowercase :    int							=							[]

	def generate(__UpperCAmelCase     ,__UpperCAmelCase			):
		_lowercase :    Dict							=							[0] * n
		res.append(tuple(__UpperCAmelCase			)			)

		_lowercase :    List[str]							=							0
		while i < n:
			if c[i] < i:
				if i % 2 == 0:
					_lowercase				,      _lowercase :    Union[str, Any]							=							arr[i], arr[0]
				else:
					_lowercase				,      _lowercase :    Union[str, Any]							=							arr[i], arr[c[i]]
				res.append(tuple(__UpperCAmelCase			)			)
				c[i] += 1
				_lowercase :    Optional[Any]							=							0
			else:
				_lowercase :    str							=							0
				i += 1

	generate(len(__UpperCAmelCase			)     ,__UpperCAmelCase			)
	return res


if __name__ == "__main__":
						SCREAMING_SNAKE_CASE									=						input('Enter numbers separated by a comma:\n').strip()
						SCREAMING_SNAKE_CASE									=						[int(item) for item in user_input.split(',')]
						print(heaps(arr))




"""simple docstring"""







import importlib
import json
import os
from collections import OrderedDict
from typing import Dict, Optional, Union

# Build the list of all feature extractors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...feature_extraction_utils import FeatureExtractionMixin
from ...utils import CONFIG_NAME, FEATURE_EXTRACTOR_NAME, get_file_from_repo, logging
from .auto_factory import _LazyAutoMapping
from .configuration_auto import (
    CONFIG_MAPPING_NAMES,
    AutoConfig,
    model_type_to_module_name,
    replace_list_option_in_docstrings,
)


SCREAMING_SNAKE_CASE									=						logging.get_logger(__name__)

SCREAMING_SNAKE_CASE									=						OrderedDict(
    [
        ('audio-spectrogram-transformer', 'ASTFeatureExtractor'),
        ('beit', 'BeitFeatureExtractor'),
        ('chinese_clip', 'ChineseCLIPFeatureExtractor'),
        ('clap', 'ClapFeatureExtractor'),
        ('clip', 'CLIPFeatureExtractor'),
        ('clipseg', 'ViTFeatureExtractor'),
        ('conditional_detr', 'ConditionalDetrFeatureExtractor'),
        ('convnext', 'ConvNextFeatureExtractor'),
        ('cvt', 'ConvNextFeatureExtractor'),
        ('data2vec-audio', 'Wav2Vec2FeatureExtractor'),
        ('data2vec-vision', 'BeitFeatureExtractor'),
        ('deformable_detr', 'DeformableDetrFeatureExtractor'),
        ('deit', 'DeiTFeatureExtractor'),
        ('detr', 'DetrFeatureExtractor'),
        ('dinat', 'ViTFeatureExtractor'),
        ('donut-swin', 'DonutFeatureExtractor'),
        ('dpt', 'DPTFeatureExtractor'),
        ('encodec', 'EncodecFeatureExtractor'),
        ('flava', 'FlavaFeatureExtractor'),
        ('glpn', 'GLPNFeatureExtractor'),
        ('groupvit', 'CLIPFeatureExtractor'),
        ('hubert', 'Wav2Vec2FeatureExtractor'),
        ('imagegpt', 'ImageGPTFeatureExtractor'),
        ('layoutlmv2', 'LayoutLMv2FeatureExtractor'),
        ('layoutlmv3', 'LayoutLMv3FeatureExtractor'),
        ('levit', 'LevitFeatureExtractor'),
        ('maskformer', 'MaskFormerFeatureExtractor'),
        ('mctct', 'MCTCTFeatureExtractor'),
        ('mobilenet_v1', 'MobileNetV1FeatureExtractor'),
        ('mobilenet_v2', 'MobileNetV2FeatureExtractor'),
        ('mobilevit', 'MobileViTFeatureExtractor'),
        ('nat', 'ViTFeatureExtractor'),
        ('owlvit', 'OwlViTFeatureExtractor'),
        ('perceiver', 'PerceiverFeatureExtractor'),
        ('poolformer', 'PoolFormerFeatureExtractor'),
        ('regnet', 'ConvNextFeatureExtractor'),
        ('resnet', 'ConvNextFeatureExtractor'),
        ('segformer', 'SegformerFeatureExtractor'),
        ('sew', 'Wav2Vec2FeatureExtractor'),
        ('sew-d', 'Wav2Vec2FeatureExtractor'),
        ('speech_to_text', 'Speech2TextFeatureExtractor'),
        ('speecht5', 'SpeechT5FeatureExtractor'),
        ('swiftformer', 'ViTFeatureExtractor'),
        ('swin', 'ViTFeatureExtractor'),
        ('swinv2', 'ViTFeatureExtractor'),
        ('table-transformer', 'DetrFeatureExtractor'),
        ('timesformer', 'VideoMAEFeatureExtractor'),
        ('tvlt', 'TvltFeatureExtractor'),
        ('unispeech', 'Wav2Vec2FeatureExtractor'),
        ('unispeech-sat', 'Wav2Vec2FeatureExtractor'),
        ('van', 'ConvNextFeatureExtractor'),
        ('videomae', 'VideoMAEFeatureExtractor'),
        ('vilt', 'ViltFeatureExtractor'),
        ('vit', 'ViTFeatureExtractor'),
        ('vit_mae', 'ViTFeatureExtractor'),
        ('vit_msn', 'ViTFeatureExtractor'),
        ('wav2vec2', 'Wav2Vec2FeatureExtractor'),
        ('wav2vec2-conformer', 'Wav2Vec2FeatureExtractor'),
        ('wavlm', 'Wav2Vec2FeatureExtractor'),
        ('whisper', 'WhisperFeatureExtractor'),
        ('xclip', 'CLIPFeatureExtractor'),
        ('yolos', 'YolosFeatureExtractor'),
    ]
)

SCREAMING_SNAKE_CASE									=						_LazyAutoMapping(CONFIG_MAPPING_NAMES, FEATURE_EXTRACTOR_MAPPING_NAMES)


def      __lowerCAmelCase(		__UpperCAmelCase			):






	"""simple docstring"""





	for module_name, extractors in FEATURE_EXTRACTOR_MAPPING_NAMES.items():
		if class_name in extractors:
			_lowercase :    int							=							model_type_to_module_name(__UpperCAmelCase			)

			_lowercase :    int							=							importlib.import_module(F'''.{module_name}'''     ,'transformers.models'			)
			try:
				return getattr(__UpperCAmelCase     ,__UpperCAmelCase			)
			except AttributeError:
				continue

	for _, extractor in FEATURE_EXTRACTOR_MAPPING._extra_content.items():
		if getattr(__UpperCAmelCase     ,'__name__'     ,__UpperCAmelCase			) == class_name:
			return extractor

    # We did not fine the class, but maybe it's because a dep is missing. In that case, the class will be in the main
    # init and we return the proper dummy to get an appropriate error message.
	_lowercase :    List[str]							=							importlib.import_module('transformers'			)
	if hasattr(__UpperCAmelCase     ,__UpperCAmelCase			):
		return getattr(__UpperCAmelCase     ,__UpperCAmelCase			)

	return None


def      __lowerCAmelCase(		__UpperCAmelCase     ,__UpperCAmelCase = None     ,__UpperCAmelCase = False     ,__UpperCAmelCase = False     ,__UpperCAmelCase = None     ,__UpperCAmelCase = None     ,__UpperCAmelCase = None     ,__UpperCAmelCase = False     ,**__UpperCAmelCase     ,):






	"""simple docstring"""





	_lowercase :    Any							=							get_file_from_repo(
	    __UpperCAmelCase     ,__UpperCAmelCase     ,cache_dir=__UpperCAmelCase     ,force_download=__UpperCAmelCase     ,resume_download=__UpperCAmelCase     ,proxies=__UpperCAmelCase     ,use_auth_token=__UpperCAmelCase     ,revision=__UpperCAmelCase     ,local_files_only=__UpperCAmelCase     ,)
	if resolved_config_file is None:
		logger.info(
		    'Could not locate the feature extractor configuration file, will try to use the model config instead.'			)
		return {}

	with open(__UpperCAmelCase     ,encoding='utf-8'			) as reader:
		return json.load(__UpperCAmelCase			)







class  _lowerCamelCase			:







				def __init__( self    :       List[Any]						):

					"""simple docstring"""






					raise EnvironmentError(
					    'AutoFeatureExtractor is designed to be instantiated '
					    'using the `AutoFeatureExtractor.from_pretrained(pretrained_model_name_or_path)` method.'						)







				@classmethod
				@replace_list_option_in_docstrings(lowerCamelCase_						)
				def 							__UpperCAmelCase					( cls    :       Union[str, Any]			,					lowerCamelCase_    :       str			,					**lowerCamelCase_    :       int						):

					"""simple docstring"""






					_lowercase :    Optional[Any]							=							kwargs.pop('config'			,					lowerCamelCase_						)
					_lowercase :    Optional[Any]							=							kwargs.pop('trust_remote_code'			,					lowerCamelCase_						)
					_lowercase :    Optional[int]							=							True

					_lowercase				,      _lowercase :    Dict							=							FeatureExtractionMixin.get_feature_extractor_dict(lowerCamelCase_			,					**lowerCamelCase_						)
					_lowercase :    Dict							=							config_dict.get('feature_extractor_type'			,					lowerCamelCase_						)
					_lowercase :    str							=							None
					if "AutoFeatureExtractor" in config_dict.get('auto_map'			,					{}						):
						_lowercase :    int							=							config_dict['auto_map']['AutoFeatureExtractor']

					# If we don't find the feature extractor class in the feature extractor config, let's try the model config.
					if feature_extractor_class is None and feature_extractor_auto_map is None:
						if not isinstance(lowerCamelCase_			,					lowerCamelCase_						):
							_lowercase :    Optional[int]							=							AutoConfig.from_pretrained(lowerCamelCase_			,					**lowerCamelCase_						)
						# It could be in `config.feature_extractor_type``
						_lowercase :    Tuple							=							getattr(lowerCamelCase_			,					'feature_extractor_type'			,					lowerCamelCase_						)
						if hasattr(lowerCamelCase_			,					'auto_map'						) and "AutoFeatureExtractor" in config.auto_map:
							_lowercase :    Optional[int]							=							config.auto_map['AutoFeatureExtractor']

					if feature_extractor_class is not None:
						_lowercase :    Optional[Any]							=							feature_extractor_class_from_name(lowerCamelCase_						)

					_lowercase :    int							=							feature_extractor_auto_map is not None
					_lowercase :    Dict							=							feature_extractor_class is not None or type(lowerCamelCase_						) in FEATURE_EXTRACTOR_MAPPING
					_lowercase :    List[str]							=							resolve_trust_remote_code(
					    lowerCamelCase_			,					lowerCamelCase_			,					lowerCamelCase_			,					lowerCamelCase_						)

					if has_remote_code and trust_remote_code:
						_lowercase :    Any							=							get_class_from_dynamic_module(
						    lowerCamelCase_			,					lowerCamelCase_			,					**lowerCamelCase_						)
						_lowercase :    str							=							kwargs.pop('code_revision'			,					lowerCamelCase_						)
						if os.path.isdir(lowerCamelCase_						):
							feature_extractor_class.register_for_auto_class()
						return feature_extractor_class.from_dict(lowerCamelCase_			,					**lowerCamelCase_						)
					elif feature_extractor_class is not None:
						return feature_extractor_class.from_dict(lowerCamelCase_			,					**lowerCamelCase_						)
					# Last try: we use the FEATURE_EXTRACTOR_MAPPING.
					elif type(lowerCamelCase_						) in FEATURE_EXTRACTOR_MAPPING:
						_lowercase :    List[str]							=							FEATURE_EXTRACTOR_MAPPING[type(lowerCamelCase_						)]
						return feature_extractor_class.from_dict(lowerCamelCase_			,					**lowerCamelCase_						)

					raise ValueError(
					    F'''Unrecognized feature extractor in {pretrained_model_name_or_path}. Should have a '''
					    F'''`feature_extractor_type` key in its {FEATURE_EXTRACTOR_NAME} of {CONFIG_NAME}, or one of the following '''
					    F'''`model_type` keys in its {CONFIG_NAME}: {', '.join(c for c in FEATURE_EXTRACTOR_MAPPING_NAMES.keys()						)}'''						)







				@staticmethod
				def 							__UpperCAmelCase					( lowerCamelCase_    :       Tuple			,					lowerCamelCase_    :       Dict						):

					"""simple docstring"""






					FEATURE_EXTRACTOR_MAPPING.register(lowerCamelCase_			,					lowerCamelCase_						)



