





'''simple docstring'''

import argparse
import copy
import json
import multiprocessing
import os
import time

from create_dummy_models import COMPOSITE_MODELS, create_tiny_models
from huggingface_hub import ModelFilter, hf_api

import transformers
from transformers import AutoFeatureExtractor, AutoImageProcessor, AutoTokenizer
from transformers.image_processing_utils import BaseImageProcessor


def 						__UpperCamelCase						(			):
		__UpperCAmelCase	:							int     =     set()
		# Each auto modeling files contains multiple mappings. Let's get them in a dynamic way.
		for module_name in ["modeling_auto", "modeling_tf_auto", "modeling_flax_auto"]:
				__UpperCAmelCase	:							Union[str, Any]     =     getattr(transformers.models.auto,       _UpperCAmelCase,       _UpperCAmelCase  )
				if module is None:
						continue
				# all mappings in a single auto modeling file
				__UpperCAmelCase	:							int     =     [
				    x
				    for x in dir(_UpperCAmelCase  )
				    if x.endswith("_MAPPING_NAMES"  )
				    and (x.startswith("MODEL_"  ) or x.startswith("TF_MODEL_"  ) or x.startswith("FLAX_MODEL_"  ))
				]
				for name in mapping_names:
						__UpperCAmelCase	:							int     =     getattr(_UpperCAmelCase,       _UpperCAmelCase  )
						if mapping is not None:
								for v in mapping.values():
										if isinstance(_UpperCAmelCase,       (list, tuple)  ):
												model_names.update(_UpperCAmelCase  )
										elif isinstance(_UpperCAmelCase,       _UpperCAmelCase  ):
												model_names.add(_UpperCAmelCase  )

		return sorted(_UpperCAmelCase  )


def 						__UpperCamelCase						(			):
		# All model names defined in auto mappings
		__UpperCAmelCase	:							Optional[int]     =     set(get_all_model_names()  )

		with open("tests/utils/tiny_model_summary.json"  ) as fp:
				__UpperCAmelCase	:							List[str]     =     json.load(_UpperCAmelCase  )
		__UpperCAmelCase	:							str     =     set()
		for model_base_name in tiny_model_info:
				tiny_models_names.update(tiny_model_info[model_base_name]["model_classes"]  )

		# Remove a tiny model name if one of its framework implementation hasn't yet a tiny version on the Hub.
		__UpperCAmelCase	:							Dict     =     model_names.difference(_UpperCAmelCase  )
		for model_name in copy.copy(_UpperCAmelCase  ):
				if not model_name.startswith("TF"  ) and F"TF{model_name}" in not_on_hub:
						tiny_models_names.remove(_UpperCAmelCase  )
				elif model_name.startswith("TF"  ) and model_name[2:] in not_on_hub:
						tiny_models_names.remove(_UpperCAmelCase  )

		return sorted(_UpperCAmelCase  )


def 						__UpperCamelCase						(			_UpperCAmelCase  ):
		__UpperCAmelCase	:							Optional[Any]     =     COMPOSITE_MODELS.values()

		# All tiny model base names on Hub
		__UpperCAmelCase	:							Optional[Any]     =     get_all_model_names()
		__UpperCAmelCase	:							int     =     hf_api.list_models(
		    filter=ModelFilter(
		        author="hf-internal-testing",       )  )
		__UpperCAmelCase	:							int     =     set()
		for x in models:
				__UpperCAmelCase	:							Optional[Any]     =     x.modelId
				__UpperCAmelCase  ,			__UpperCAmelCase	:							str     =     model.split("/"  )
				if not model.startswith("tiny-random-"  ):
						continue
				__UpperCAmelCase	:							Any     =     model.replace("tiny-random-",       ""  )
				if not model[0].isupper():
						continue
				if model not in model_names and model not in special_models:
						continue
				_models.add(_UpperCAmelCase  )

		__UpperCAmelCase	:							Dict     =     sorted(_models  )
		# All tiny model names on Hub
		__UpperCAmelCase	:							Union[str, Any]     =     {}
		for model in models:
				__UpperCAmelCase	:							int     =     F"hf-internal-testing/tiny-random-{model}"
				__UpperCAmelCase	:							Dict     =     model.split("-"  )[0]
				try:
						__UpperCAmelCase	:							Any     =     hf_api.repo_info(_UpperCAmelCase  )
						__UpperCAmelCase	:							Any     =     {
						    "tokenizer_classes": set(),
						    "processor_classes": set(),
						    "model_classes": set(),
						    "sha": repo_info.sha,
						}
				except Exception:
						continue
				try:
						time.sleep(1  )
						__UpperCAmelCase	:							Tuple     =     AutoTokenizer.from_pretrained(_UpperCAmelCase  )
						content["tokenizer_classes"].add(tokenizer_fast.__class__.__name__  )
				except Exception:
						pass
				try:
						time.sleep(1  )
						__UpperCAmelCase	:							Any     =     AutoTokenizer.from_pretrained(_UpperCAmelCase,       use_fast=_UpperCAmelCase  )
						content["tokenizer_classes"].add(tokenizer_slow.__class__.__name__  )
				except Exception:
						pass
				try:
						time.sleep(1  )
						__UpperCAmelCase	:							List[Any]     =     AutoImageProcessor.from_pretrained(_UpperCAmelCase  )
						content["processor_classes"].add(img_p.__class__.__name__  )
				except Exception:
						pass
				try:
						time.sleep(1  )
						__UpperCAmelCase	:							Optional[int]     =     AutoFeatureExtractor.from_pretrained(_UpperCAmelCase  )
						if not isinstance(_UpperCAmelCase,       _UpperCAmelCase  ):
								content["processor_classes"].add(feat_p.__class__.__name__  )
				except Exception:
						pass
				try:
						time.sleep(1  )
						__UpperCAmelCase	:							Union[str, Any]     =     getattr(_UpperCAmelCase,       _UpperCAmelCase  )
						__UpperCAmelCase	:							Optional[Any]     =     model_class.from_pretrained(_UpperCAmelCase  )
						content["model_classes"].add(m.__class__.__name__  )
				except Exception:
						pass
				try:
						time.sleep(1  )
						__UpperCAmelCase	:							List[Any]     =     getattr(_UpperCAmelCase,       F"TF{model}"  )
						__UpperCAmelCase	:							Optional[int]     =     model_class.from_pretrained(_UpperCAmelCase  )
						content["model_classes"].add(m.__class__.__name__  )
				except Exception:
						pass

				__UpperCAmelCase	:							Any     =     sorted(content["tokenizer_classes"]  )
				__UpperCAmelCase	:							int     =     sorted(content["processor_classes"]  )
				__UpperCAmelCase	:							str     =     sorted(content["model_classes"]  )

				__UpperCAmelCase	:							List[str]     =     content
				with open(os.path.join(_UpperCAmelCase,       "hub_tiny_model_summary.json"  ),       "w"  ) as fp:
						json.dump(_UpperCAmelCase,       _UpperCAmelCase,       ensure_ascii=_UpperCAmelCase,       indent=4  )


if __name__ == "__main__":
			lowerCAmelCase__      :   List[str]      	=			argparse.ArgumentParser()
			parser.add_argument("--num_workers", default=1, type=int, help="The number of workers to run.")
			lowerCAmelCase__      :   Union[str, Any]      	=			parser.parse_args()

			# This has to be `spawn` to avoid hanging forever!
			multiprocessing.set_start_method("spawn")

			lowerCAmelCase__      :   List[str]      	=			"tiny_models"
			lowerCAmelCase__      :   Tuple      	=			True
			lowerCAmelCase__      :   str      	=			None
			lowerCAmelCase__      :   List[Any]      	=			get_tiny_model_names_from_repo()
			lowerCAmelCase__      :   Union[str, Any]      	=			True
			lowerCAmelCase__      :   Dict      	=			True
			lowerCAmelCase__      :   str      	=			"hf-internal-testing"

			create_tiny_models(
			    output_path,
			    all,
			    model_types,
			    models_to_skip,
			    no_check,
			    upload,
			    organization,
			    token=os.environ.get("TOKEN", None),
			    num_workers=args.num_workers,
			)











'''simple docstring'''

from __future__ import annotations

lowerCAmelCase__      :   Tuple      	=			{1: 1}


def 						__UpperCamelCase						(			_UpperCAmelCase  ):
		if n in COLLATZ_SEQUENCE_LENGTHS:
				return COLLATZ_SEQUENCE_LENGTHS[n]
		__UpperCAmelCase	:							int     =     n // 2 if n % 2 == 0 else 3 * n + 1
		__UpperCAmelCase	:							str     =     collatz_sequence_length(_UpperCAmelCase  ) + 1
		__UpperCAmelCase	:							Union[str, Any]     =     sequence_length
		return sequence_length


def 						__UpperCamelCase						(			_UpperCAmelCase = 1000000  ):
		__UpperCAmelCase	:							Union[str, Any]     =     max((collatz_sequence_length(_UpperCAmelCase  ), i) for i in range(1,       _UpperCAmelCase  )  )
		return result[1]


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




