



import copy
import tempfile
import unittest

from huggingface_hub import HfFolder, delete_repo
from parameterized import parameterized
from requests.exceptions import HTTPError

from transformers import AutoConfig, GenerationConfig
from transformers.testing_utils import TOKEN, USER, is_staging_test



class 						UpperCAmelCase_					( unittest.TestCase):







							@parameterized.expand([(None,), ("foo.json",)])
							def      snake_case__   (     self,    __a):

														'''simple docstring'''

														_lowerCAmelCase  :							Union[str, Any]				     =					GenerationConfig(
														    do_sample=__a,    temperature=0.7,    length_penalty=1.0,    bad_words_ids=[[1, 2, 3], [4, 5]],    )
														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(__a,    config_name=__a)
																					_lowerCAmelCase  :							Any				     =					GenerationConfig.from_pretrained(__a,    config_name=__a)

														# Checks parameters that were specified
														self.assertEqual(loaded_config.do_sample,    __a)
														self.assertEqual(loaded_config.temperature,    0.7)
														self.assertEqual(loaded_config.length_penalty,    1.0)
														self.assertEqual(loaded_config.bad_words_ids,    [[1, 2, 3], [4, 5]])

														# Checks parameters that were not specified (defaults)
														self.assertEqual(loaded_config.top_k,    50)
														self.assertEqual(loaded_config.max_length,    20)
														self.assertEqual(loaded_config.max_time,    __a)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					AutoConfig.from_pretrained("gpt2")
														_lowerCAmelCase  :							int				     =					GenerationConfig.from_model_config(__a)
														_lowerCAmelCase  :							int				     =					GenerationConfig()

														# The generation config has loaded a few non-default parameters from the model config
														self.assertNotEqual(__a,    __a)

														# One of those parameters is eos_token_id -- check if it matches
														self.assertNotEqual(generation_config_from_model.eos_token_id,    default_generation_config.eos_token_id)
														self.assertEqual(generation_config_from_model.eos_token_id,    model_config.eos_token_id)







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					GenerationConfig()
														_lowerCAmelCase  :							int				     =					{
														    "max_new_tokens": 1024,
														    "foo": "bar",
														}
														_lowerCAmelCase  :							Dict				     =					copy.deepcopy(__a)
														_lowerCAmelCase  :							List[Any]				     =					generation_config.update(**__a)

														# update_kwargs was not modified (no side effects)
														self.assertEqual(__a,    __a)

														# update_kwargs was used to update the config on valid attributes
														self.assertEqual(generation_config.max_new_tokens,    1024)

														# `.update()` returns a dictionary of unused kwargs
														self.assertEqual(__a,    {"foo": "bar"})







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Optional[int]				     =					GenerationConfig()
														_lowerCAmelCase  :							Tuple				     =					"bar"

														with tempfile.TemporaryDirectory("test-generation-config") as tmp_dir:
																					generation_config.save_pretrained(__a)

																					_lowerCAmelCase  :							Tuple				     =					GenerationConfig.from_pretrained(__a)
														# update_kwargs was used to update the config on valid attributes
														self.assertEqual(new_config.foo,    "bar")

														_lowerCAmelCase  :							List[str]				     =					GenerationConfig.from_model_config(__a)
														assert not hasattr(__a,    "foo")  # no new kwargs should be initialized if from config







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							Union[str, Any]				     =					GenerationConfig()
														self.assertEqual(default_config.temperature,    1.0)
														self.assertEqual(default_config.do_sample,    __a)
														self.assertEqual(default_config.num_beams,    1)

														_lowerCAmelCase  :							Any				     =					GenerationConfig(
														    do_sample=__a,    temperature=0.7,    length_penalty=1.0,    bad_words_ids=[[1, 2, 3], [4, 5]],    )
														self.assertEqual(config.temperature,    0.7)
														self.assertEqual(config.do_sample,    __a)
														self.assertEqual(config.num_beams,    1)

														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(__a)
																					_lowerCAmelCase  :							Union[str, Any]				     =					GenerationConfig.from_pretrained(__a,    temperature=1.0)

														self.assertEqual(loaded_config.temperature,    1.0)
														self.assertEqual(loaded_config.do_sample,    __a)
														self.assertEqual(loaded_config.num_beams,    1)  # default value



@is_staging_test
class 						UpperCAmelCase_					( unittest.TestCase):







							@classmethod
							def      snake_case__   (     cls):

														'''simple docstring'''

														_lowerCAmelCase  :							Dict				     =					TOKEN
														HfFolder.save_token(__a)







							@classmethod
							def      snake_case__   (     cls):

														'''simple docstring'''

														try:
																					delete_repo(token=cls._token,    repo_id="test-generation-config")
														except HTTPError:
																					pass

														try:
																					delete_repo(token=cls._token,    repo_id="valid_org/test-generation-config-org")
														except HTTPError:
																					pass







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							int				     =					GenerationConfig(
														    do_sample=__a,    temperature=0.7,    length_penalty=1.0,    )
														config.push_to_hub("test-generation-config",    use_auth_token=self._token)

														_lowerCAmelCase  :							str				     =					GenerationConfig.from_pretrained(f"{USER}/test-generation-config")
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(__a,    getattr(__a,    __a))

        # Reset repo
														delete_repo(token=self._token,    repo_id="test-generation-config")

														# Push to hub via save_pretrained
														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(
																					    __a,    repo_id="test-generation-config",    push_to_hub=__a,    use_auth_token=self._token)

														_lowerCAmelCase  :							Tuple				     =					GenerationConfig.from_pretrained(f"{USER}/test-generation-config")
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(__a,    getattr(__a,    __a))







							def      snake_case__   (     self):

														'''simple docstring'''

														_lowerCAmelCase  :							str				     =					GenerationConfig(
														    do_sample=__a,    temperature=0.7,    length_penalty=1.0,    )
														config.push_to_hub("valid_org/test-generation-config-org",    use_auth_token=self._token)

														_lowerCAmelCase  :							List[Any]				     =					GenerationConfig.from_pretrained("valid_org/test-generation-config-org")
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(__a,    getattr(__a,    __a))

        # Reset repo
														delete_repo(token=self._token,    repo_id="valid_org/test-generation-config-org")

														# Push to hub via save_pretrained
														with tempfile.TemporaryDirectory() as tmp_dir:
																					config.save_pretrained(
																					    __a,    repo_id="valid_org/test-generation-config-org",    push_to_hub=__a,    use_auth_token=self._token)

														_lowerCAmelCase  :							int				     =					GenerationConfig.from_pretrained("valid_org/test-generation-config-org")
														for k, v in config.to_dict().items():
																					if k != "transformers_version":
																												self.assertEqual(__a,    getattr(__a,    __a))





def        A       (      _lowerCamelCase = 1_000_000						):





							'''simple docstring'''




							_lowerCAmelCase  :							Any				     =					1
							_lowerCAmelCase  :							Optional[Any]				     =					1
							_lowerCAmelCase  :							List[str]				     =					{1: 1}

							for inputa in range(2       ,				_lowerCamelCase						):
														_lowerCAmelCase  :							int				     =					0
														_lowerCAmelCase  :							Any				     =					inputa

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

														if inputa not in counters:
																					_lowerCAmelCase  :							Tuple				     =					counter

														if counter > pre_counter:
																					_lowerCAmelCase  :							Union[str, Any]				     =					inputa
																					_lowerCAmelCase  :							Union[str, Any]				     =					counter
							return largest_number


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