




"""simple docstring"""




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

# Build the list of all image processors
from ...configuration_utils import PretrainedConfig
from ...dynamic_module_utils import get_class_from_dynamic_module, resolve_trust_remote_code
from ...image_processing_utils import ImageProcessingMixin
from ...utils import CONFIG_NAME, IMAGE_PROCESSOR_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,
)


lowerCAmelCase							:			str     							=							logging.get_logger(__name__)

lowerCAmelCase							:			Union[str, Any]     							=							OrderedDict(
    [
        ("""align""", """EfficientNetImageProcessor"""),
        ("""beit""", """BeitImageProcessor"""),
        ("""bit""", """BitImageProcessor"""),
        ("""blip""", """BlipImageProcessor"""),
        ("""blip-2""", """BlipImageProcessor"""),
        ("""bridgetower""", """BridgeTowerImageProcessor"""),
        ("""chinese_clip""", """ChineseCLIPImageProcessor"""),
        ("""clip""", """CLIPImageProcessor"""),
        ("""clipseg""", """ViTImageProcessor"""),
        ("""conditional_detr""", """ConditionalDetrImageProcessor"""),
        ("""convnext""", """ConvNextImageProcessor"""),
        ("""convnextv2""", """ConvNextImageProcessor"""),
        ("""cvt""", """ConvNextImageProcessor"""),
        ("""data2vec-vision""", """BeitImageProcessor"""),
        ("""deformable_detr""", """DeformableDetrImageProcessor"""),
        ("""deit""", """DeiTImageProcessor"""),
        ("""deta""", """DetaImageProcessor"""),
        ("""detr""", """DetrImageProcessor"""),
        ("""dinat""", """ViTImageProcessor"""),
        ("""donut-swin""", """DonutImageProcessor"""),
        ("""dpt""", """DPTImageProcessor"""),
        ("""efficientformer""", """EfficientFormerImageProcessor"""),
        ("""efficientnet""", """EfficientNetImageProcessor"""),
        ("""flava""", """FlavaImageProcessor"""),
        ("""focalnet""", """BitImageProcessor"""),
        ("""git""", """CLIPImageProcessor"""),
        ("""glpn""", """GLPNImageProcessor"""),
        ("""groupvit""", """CLIPImageProcessor"""),
        ("""imagegpt""", """ImageGPTImageProcessor"""),
        ("""instructblip""", """BlipImageProcessor"""),
        ("""layoutlmv2""", """LayoutLMv2ImageProcessor"""),
        ("""layoutlmv3""", """LayoutLMv3ImageProcessor"""),
        ("""levit""", """LevitImageProcessor"""),
        ("""mask2former""", """Mask2FormerImageProcessor"""),
        ("""maskformer""", """MaskFormerImageProcessor"""),
        ("""mgp-str""", """ViTImageProcessor"""),
        ("""mobilenet_v1""", """MobileNetV1ImageProcessor"""),
        ("""mobilenet_v2""", """MobileNetV2ImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevit""", """MobileViTImageProcessor"""),
        ("""mobilevitv2""", """MobileViTImageProcessor"""),
        ("""nat""", """ViTImageProcessor"""),
        ("""oneformer""", """OneFormerImageProcessor"""),
        ("""owlvit""", """OwlViTImageProcessor"""),
        ("""perceiver""", """PerceiverImageProcessor"""),
        ("""pix2struct""", """Pix2StructImageProcessor"""),
        ("""poolformer""", """PoolFormerImageProcessor"""),
        ("""regnet""", """ConvNextImageProcessor"""),
        ("""resnet""", """ConvNextImageProcessor"""),
        ("""sam""", """SamImageProcessor"""),
        ("""segformer""", """SegformerImageProcessor"""),
        ("""swiftformer""", """ViTImageProcessor"""),
        ("""swin""", """ViTImageProcessor"""),
        ("""swin2sr""", """Swin2SRImageProcessor"""),
        ("""swinv2""", """ViTImageProcessor"""),
        ("""table-transformer""", """DetrImageProcessor"""),
        ("""timesformer""", """VideoMAEImageProcessor"""),
        ("""tvlt""", """TvltImageProcessor"""),
        ("""upernet""", """SegformerImageProcessor"""),
        ("""van""", """ConvNextImageProcessor"""),
        ("""videomae""", """VideoMAEImageProcessor"""),
        ("""vilt""", """ViltImageProcessor"""),
        ("""vit""", """ViTImageProcessor"""),
        ("""vit_hybrid""", """ViTHybridImageProcessor"""),
        ("""vit_mae""", """ViTImageProcessor"""),
        ("""vit_msn""", """ViTImageProcessor"""),
        ("""xclip""", """CLIPImageProcessor"""),
        ("""yolos""", """YolosImageProcessor"""),
    ]
)

lowerCAmelCase							:			List[Any]     							=							_LazyAutoMapping(CONFIG_MAPPING_NAMES, IMAGE_PROCESSOR_MAPPING_NAMES)



def     a__ (				snake_case__				)						->					str:
			for module_name, extractors in IMAGE_PROCESSOR_MAPPING_NAMES.items():
						if class_name in extractors:
									lowerCamelCase			      =					model_type_to_module_name(__snake_case				)

									lowerCamelCase			      =					importlib.import_module(F'.{module_name}'       , """transformers.models"""				)
									try:
												return getattr(__snake_case       , __snake_case				)
									except AttributeError:
												continue

			for _, extractor in IMAGE_PROCESSOR_MAPPING._extra_content.items():
						if getattr(__snake_case       , """__name__"""       , __snake_case				) == 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.
			lowerCamelCase			      =					importlib.import_module("""transformers"""				)
			if hasattr(__snake_case       , __snake_case				):
						return getattr(__snake_case       , __snake_case				)

			return None



def     a__ (				snake_case__       , snake_case__ = None       , snake_case__ = False       , snake_case__ = False       , snake_case__ = None       , snake_case__ = None       , snake_case__ = None       , snake_case__ = False       , **snake_case__       , )						->					str:
			lowerCamelCase			      =					get_file_from_repo(
			    __snake_case       , __snake_case       , cache_dir=__snake_case       , force_download=__snake_case       , resume_download=__snake_case       , proxies=__snake_case       , use_auth_token=__snake_case       , revision=__snake_case       , local_files_only=__snake_case       , )
			if resolved_config_file is None:
						logger.info(
						    """Could not locate the image processor configuration file, will try to use the model config instead."""				)
						return {}

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






class     __magic_name__							:






				'''simple docstring'''





				def __init__(       self ):





							"""simple docstring"""
							raise EnvironmentError(
							    """AutoImageProcessor is designed to be instantiated """
							    """using the `AutoImageProcessor.from_pretrained(pretrained_model_name_or_path)` method.""" )





				@classmethod
				@replace_list_option_in_docstrings(_a )
				def    _lowerCAmelCase				(       cls		, _a		, **_a ):





							"""simple docstring"""
							lowerCamelCase			      =					kwargs.pop("""config"""		, _a )
							lowerCamelCase			      =					kwargs.pop("""trust_remote_code"""		, _a )
							lowerCamelCase			      =					True

							lowerCamelCase			      =					ImageProcessingMixin.get_image_processor_dict(_a		, **_a )
							lowerCamelCase			      =					config_dict.get("""image_processor_type"""		, _a )
							lowerCamelCase			      =					None
							if "AutoImageProcessor" in config_dict.get("""auto_map"""		, {} ):
										lowerCamelCase			      =					config_dict['''auto_map''']['''AutoImageProcessor''']

							# If we still don't have the image processor class, check if we're loading from a previous feature extractor config
							# and if so, infer the image processor class from there.
							if image_processor_class is None and image_processor_auto_map is None:
										lowerCamelCase			      =					config_dict.pop("""feature_extractor_type"""		, _a )
										if feature_extractor_class is not None:
													logger.warning(
													    """Could not find image processor class in the image processor config or the model config. Loading"""
													    """ based on pattern matching with the model\'s feature extractor configuration.""" )
													lowerCamelCase			      =					feature_extractor_class.replace("""FeatureExtractor"""		, """ImageProcessor""" )
										if "AutoFeatureExtractor" in config_dict.get("""auto_map"""		, {} ):
													lowerCamelCase			      =					config_dict['''auto_map''']['''AutoFeatureExtractor''']
													lowerCamelCase			      =					feature_extractor_auto_map.replace("""FeatureExtractor"""		, """ImageProcessor""" )
													logger.warning(
													    """Could not find image processor auto map in the image processor config or the model config."""
													    """ Loading based on pattern matching with the model\'s feature extractor configuration.""" )

        # If we don't find the image processor class in the image processor config, let's try the model config.
							if image_processor_class is None and image_processor_auto_map is None:
										if not isinstance(_a		, _a ):
													lowerCamelCase			      =					AutoConfig.from_pretrained(_a		, **_a )
										# It could be in `config.image_processor_type``
										lowerCamelCase			      =					getattr(_a		, """image_processor_type"""		, _a )
										if hasattr(_a		, """auto_map""" ) and "AutoImageProcessor" in config.auto_map:
													lowerCamelCase			      =					config.auto_map['''AutoImageProcessor''']

							if image_processor_class is not None:
										lowerCamelCase			      =					image_processor_class_from_name(_a )

							lowerCamelCase			      =					image_processor_auto_map is not None
							lowerCamelCase			      =					image_processor_class is not None or type(_a ) in IMAGE_PROCESSOR_MAPPING
							lowerCamelCase			      =					resolve_trust_remote_code(
							    _a		, _a		, _a		, _a )

							if has_remote_code and trust_remote_code:
										lowerCamelCase			      =					get_class_from_dynamic_module(
										    _a		, _a		, **_a )
										lowerCamelCase			      =					kwargs.pop("""code_revision"""		, _a )
										if os.path.isdir(_a ):
													image_processor_class.register_for_auto_class()
										return image_processor_class.from_dict(_a		, **_a )
							elif image_processor_class is not None:
										return image_processor_class.from_dict(_a		, **_a )
							# Last try: we use the IMAGE_PROCESSOR_MAPPING.
							elif type(_a ) in IMAGE_PROCESSOR_MAPPING:
										lowerCamelCase			      =					IMAGE_PROCESSOR_MAPPING[type(_a )]
										return image_processor_class.from_dict(_a		, **_a )

							raise ValueError(
							    f'Unrecognized image processor in {pretrained_model_name_or_path}. Should have a '
							    f'`image_processor_type` key in its {IMAGE_PROCESSOR_NAME} of {CONFIG_NAME}, or one of the following '
							    f'`model_type` keys in its {CONFIG_NAME}: {", ".join(c for c in IMAGE_PROCESSOR_MAPPING_NAMES.keys() )}' )





				@staticmethod
				def    _lowerCAmelCase				(       _a		, _a ):





							"""simple docstring"""
							IMAGE_PROCESSOR_MAPPING.register(_a		, _a )











"""simple docstring"""



def 						lowercase    (				__snake_case				: int = 1_0_0_0	):
		lowercase_       ,					lowercase_ : str							       =   1, 1
		lowercase_ : List[str]							       =   2
		while True:
				lowercase_ : Tuple							       =   0
				lowercase_ : List[Any]							       =   fa + fa
				lowercase_       ,					lowercase_ : Optional[int]							       =   fa, f
				index += 1
				for _ in str(__snake_case	):
						i += 1
				if i == n:
						break
		return index


if __name__ == "__main__":
						print(solution(int(str(input()).strip())))



