






import importlib
import inspect
import json
import os
import re
import shutil
import sys
from pathlib import Path
from typing import Dict, Optional, Union
from urllib import request

from huggingface_hub import HfFolder, cached_download, hf_hub_download, model_info
from packaging import version

from .. import __version__
from . import DIFFUSERS_DYNAMIC_MODULE_NAME, HF_MODULES_CACHE, logging


__A      =				(
    'https://raw.githubusercontent.com/huggingface/diffusers/{revision}/examples/community/{pipeline}.py'
)


__A      =				logging.get_logger(__name__)  # pylint: disable=invalid-name




def      __A					(     ):

					'''simple docstring'''







					_A								= '''https://pypi.org/pypi/diffusers/json'''
					_A								= json.loads(request.urlopen(_lowercase ).read() )['''releases'''].keys()
					return sorted(_lowercase					,			key=lambda _lowercase : version.Version(_lowercase ) )




def      __A					(     ):

					'''simple docstring'''







					if HF_MODULES_CACHE in sys.path:
										return

					sys.path.append(_lowercase )
					os.makedirs(_lowercase					,			exist_ok=_lowercase )
					_A								= Path(_lowercase ) / '''__init__.py'''
					if not init_path.exists():
										init_path.touch()




def      __A					(     _lowercase ):

					'''simple docstring'''







					init_hf_modules()
					_A								= Path(_lowercase ) / name
					# If the parent module does not exist yet, recursively create it.
					if not dynamic_module_path.parent.exists():
										create_dynamic_module(dynamic_module_path.parent )
					os.makedirs(_lowercase					,			exist_ok=_lowercase )
					_A								= dynamic_module_path / '''__init__.py'''
					if not init_path.exists():
										init_path.touch()




def      __A					(     _lowercase ):

					'''simple docstring'''







					with open(_lowercase					,			'''r'''					,			encoding='''utf-8''' ) as f:
										_A								= f.read()

					# Imports of the form `import .xxx`
					_A								= re.findall('''^\s*import\s+\.(\S+)\s*$'''					,			_lowercase					,			flags=re.MULTILINE )
					# Imports of the form `from .xxx import yyy`
					relative_imports += re.findall('''^\s*from\s+\.(\S+)\s+import'''					,			_lowercase					,			flags=re.MULTILINE )
					# Unique-ify
					return list(set(_lowercase ) )




def      __A					(     _lowercase ):

					'''simple docstring'''







					_A								= False
					_A								= [module_file]
					_A								= []

					# Let's recurse through all relative imports
					while not no_change:
										_A								= []
										for f in files_to_check:
															new_imports.extend(get_relative_imports(_lowercase ) )

										_A								= Path(_lowercase ).parent
										_A								= [str(module_path / m ) for m in new_imports]
										_A								= [f for f in new_import_files if f not in all_relative_imports]
										_A								= [f"""{f}.py""" for f in new_import_files]

										_A								= len(_lowercase ) == 0
										all_relative_imports.extend(_lowercase )

					return all_relative_imports




def      __A					(     _lowercase ):

					'''simple docstring'''







					with open(_lowercase					,			'''r'''					,			encoding='''utf-8''' ) as f:
										_A								= f.read()

					# Imports of the form `import xxx`
					_A								= re.findall('''^\s*import\s+(\S+)\s*$'''					,			_lowercase					,			flags=re.MULTILINE )
					# Imports of the form `from xxx import yyy`
					imports += re.findall('''^\s*from\s+(\S+)\s+import'''					,			_lowercase					,			flags=re.MULTILINE )
					# Only keep the top-level module
					_A								= [imp.split('''.''' )[0] for imp in imports if not imp.startswith('''.''' )]

					# Unique-ify and test we got them all
					_A								= list(set(_lowercase ) )
					_A								= []
					for imp in imports:
										try:
															importlib.import_module(_lowercase )
										except ImportError:
															missing_packages.append(_lowercase )

					if len(_lowercase ) > 0:
										raise ImportError(
										    '''This modeling file requires the following packages that were not found in your environment: '''
										    f"""{", ".join(_lowercase )}. Run `pip install {" ".join(_lowercase )}`""" )

					return get_relative_imports(_lowercase )




def      __A					(     _lowercase					,			_lowercase ):

					'''simple docstring'''







					_A								= module_path.replace(os.path.sep					,			'''.''' )
					_A								= importlib.import_module(_lowercase )

					if class_name is None:
										return find_pipeline_class(_lowercase )
					return getattr(_lowercase					,			_lowercase )




def      __A					(     _lowercase ):

					'''simple docstring'''







					from ..pipelines import DiffusionPipeline

					_A								= dict(inspect.getmembers(_lowercase					,			inspect.isclass ) )

					_A								= None
					for cls_name, cls in cls_members.items():
										if (
										    cls_name != DiffusionPipeline.__name__
										    and issubclass(cls					,			_lowercase )
										    and cls.__module__.split('''.''' )[0] != "diffusers"
										):
															if pipeline_class is not None:
																				raise ValueError(
																				    f"""Multiple classes that inherit from {DiffusionPipeline.__name__} have been found:"""
																				    f""" {pipeline_class.__name__}, and {cls_name}. Please make sure to define only one in"""
																				    f""" {loaded_module}.""" )
															_A								= cls

					return pipeline_class




def      __A					(     _lowercase					,			_lowercase					,			_lowercase = None					,			_lowercase = False					,			_lowercase = False					,			_lowercase = None					,			_lowercase = None					,			_lowercase = None					,			_lowercase = False					,			):

					'''simple docstring'''







					_A								= str(_lowercase )

					_A								= os.path.join(_lowercase					,			_lowercase )

					if os.path.isfile(_lowercase ):
										_A								= module_file_or_url
										_A								= '''local'''
					elif pretrained_model_name_or_path.count('''/''' ) == 0:
										_A								= get_diffusers_versions()
										# cut ".dev0"
										_A								= '''v''' + '''.'''.join(__version__.split('''.''' )[:3] )

										# retrieve github version that matches
										if revision is None:
															_A								= latest_version if latest_version[1:] in available_versions else '''main'''
															logger.info(f"""Defaulting to latest_version: {revision}.""" )
										elif revision in available_versions:
															_A								= f"""v{revision}"""
										elif revision == "main":
															_A								= revision
										else:
															raise ValueError(
															    f"""`custom_revision`: {revision} does not exist. Please make sure to choose one of"""
															    f""" {", ".join(available_versions + ["main"] )}.""" )

										# community pipeline on GitHub
										_A								= COMMUNITY_PIPELINES_URL.format(revision=_lowercase					,			pipeline=_lowercase )
										try:
															_A								= cached_download(
															    _lowercase					,			cache_dir=_lowercase					,			force_download=_lowercase					,			proxies=_lowercase					,			resume_download=_lowercase					,			local_files_only=_lowercase					,			use_auth_token=_lowercase					,			)
															_A								= '''git'''
															_A								= pretrained_model_name_or_path + '''.py'''
										except EnvironmentError:
															logger.error(f"""Could not locate the {module_file} inside {pretrained_model_name_or_path}.""" )
															raise
					else:
										try:
															# Load from URL or cache if already cached
															_A								= hf_hub_download(
															    _lowercase					,			_lowercase					,			cache_dir=_lowercase					,			force_download=_lowercase					,			proxies=_lowercase					,			resume_download=_lowercase					,			local_files_only=_lowercase					,			use_auth_token=_lowercase					,			)
															_A								= os.path.join('''local'''					,			'''--'''.join(pretrained_model_name_or_path.split('''/''' ) ) )
										except EnvironmentError:
															logger.error(f"""Could not locate the {module_file} inside {pretrained_model_name_or_path}.""" )
															raise

    # Check we have all the requirements in our environment
					_A								= check_imports(_lowercase )

					# Now we move the module inside our cached dynamic modules.
					_A								= DIFFUSERS_DYNAMIC_MODULE_NAME + os.path.sep + submodule
					create_dynamic_module(_lowercase )
					_A								= Path(_lowercase ) / full_submodule
					if submodule == "local" or submodule == "git":
										# We always copy local files (we could hash the file to see if there was a change, and give them the name of
										# that hash, to only copy when there is a modification but it seems overkill for now).
										# The only reason we do the copy is to avoid putting too many folders in sys.path.
										shutil.copy(_lowercase					,			submodule_path / module_file )
										for module_needed in modules_needed:
															_A								= f"""{module_needed}.py"""
															shutil.copy(os.path.join(_lowercase					,			_lowercase )					,			submodule_path / module_needed )
					else:
										# Get the commit hash
										# TODO: we will get this info in the etag soon, so retrieve it from there and not here.
										if isinstance(_lowercase					,			_lowercase ):
															_A								= use_auth_token
										elif use_auth_token is True:
															_A								= HfFolder.get_token()
										else:
															_A								= None

										_A								= model_info(_lowercase					,			revision=_lowercase					,			token=_lowercase ).sha

										# The module file will end up being placed in a subfolder with the git hash of the repo. This way we get the
										# benefit of versioning.
										_A								= submodule_path / commit_hash
										_A								= full_submodule + os.path.sep + commit_hash
										create_dynamic_module(_lowercase )

										if not (submodule_path / module_file).exists():
															shutil.copy(_lowercase					,			submodule_path / module_file )
										# Make sure we also have every file with relative
										for module_needed in modules_needed:
															if not (submodule_path / module_needed).exists():
																				get_cached_module_file(
																				    _lowercase					,			f"""{module_needed}.py"""					,			cache_dir=_lowercase					,			force_download=_lowercase					,			resume_download=_lowercase					,			proxies=_lowercase					,			use_auth_token=_lowercase					,			revision=_lowercase					,			local_files_only=_lowercase					,			)
					return os.path.join(_lowercase					,			_lowercase )




def      __A					(     _lowercase					,			_lowercase					,			_lowercase = None					,			_lowercase = None					,			_lowercase = False					,			_lowercase = False					,			_lowercase = None					,			_lowercase = None					,			_lowercase = None					,			_lowercase = False					,			**_lowercase					,			):

					'''simple docstring'''







					_A								= get_cached_module_file(
					    _lowercase					,			_lowercase					,			cache_dir=_lowercase					,			force_download=_lowercase					,			resume_download=_lowercase					,			proxies=_lowercase					,			use_auth_token=_lowercase					,			revision=_lowercase					,			local_files_only=_lowercase					,			)
					return get_class_in_module(_lowercase					,			final_module.replace('''.py'''					,			'''''' ) )











def      __A					(     _lowercase = 1_00_00_00 ):

					'''simple docstring'''







					_A								= 1
					_A								= 1
					_A								= {1: 1}

					for inputa in range(2					,			_lowercase ):
										_A								= 0
										_A								= inputa

										while True:
															if number in counters:
																				counter += counters[number]
																				break
															if number % 2 == 0:
																				number //= 2
																				counter += 1
															else:
																				_A								= (3 * number) + 1
																				counter += 1

										if inputa not in counters:
															_A								= counter

										if counter > pre_counter:
															_A								= inputa
															_A								= counter
					return largest_number


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



