




import sys
import tempfile
import unittest
import unittest.mock as mock
from pathlib import Path

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

from transformers import AutoFeatureExtractor, WavaVecaFeatureExtractor
from transformers.testing_utils import TOKEN, USER, get_tests_dir, is_staging_test


sys.path.append(str(Path(__file__).parent.parent / 'utils'))

from test_module.custom_feature_extraction import CustomFeatureExtractor  # noqa E402


SCREAMING_SNAKE_CASE__       :      Union[str, Any]  =   get_tests_dir('fixtures')




class 		UpperCamelCase__	(unittest.TestCase     ):

    '''simple docstring'''



    def     _lowercase     (    self     )     ->      List[str]:
           # A mock response for an HTTP head request to emulate server down
           lowerCamelCase   :      Optional[Any]			 =					mock.Mock()
           lowerCamelCase   :      Union[str, Any]			 =					500
           lowerCamelCase   :      str			 =					{}
           lowerCamelCase   :      Any			 =					HTTPError
           lowerCamelCase   :      List[Any]			 =					{}

           # Download this model to make sure it's in the cache.
           lowerCamelCase   :      Union[str, Any]			 =					WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"     )
           # Under the mock environment we get a 500 error when trying to reach the model.
           with mock.patch("requests.Session.request"     ,  return_value=UpperCamelCase__     ) as mock_head:
                  lowerCamelCase   :      List[Any]			 =					WavaVecaFeatureExtractor.from_pretrained("hf-internal-testing/tiny-random-wav2vec2"     )
                  # This check we did call the fake head request
                  mock_head.assert_called()







    def     _lowercase     (    self     )     ->      Union[str, Any]:
           # This test is for deprecated behavior and can be removed in v5
           lowerCamelCase   :      str			 =					WavaVecaFeatureExtractor.from_pretrained(
               "https://huggingface.co/hf-internal-testing/tiny-random-wav2vec2/resolve/main/preprocessor_config.json"     )




@is_staging_test
class 		UpperCamelCase__	(unittest.TestCase     ):

    '''simple docstring'''



    @classmethod
    def     _lowercase     (    cls     )     ->      Optional[Any]:
           lowerCamelCase   :      Any			 =					TOKEN
           HfFolder.save_token(UpperCamelCase__     )







    @classmethod
    def     _lowercase     (    cls     )     ->      Tuple:
           try:
                  delete_repo(token=cls._token     ,  repo_id="test-feature-extractor"     )
           except HTTPError:
                  pass

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

           try:
                  delete_repo(token=cls._token     ,  repo_id="test-dynamic-feature-extractor"     )
           except HTTPError:
                  pass







    def     _lowercase     (    self     )     ->      Union[str, Any]:
           lowerCamelCase   :      Any			 =					WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__     )
           feature_extractor.push_to_hub("test-feature-extractor"     ,  use_auth_token=self._token     )

           lowerCamelCase   :      Optional[Any]			 =					WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''     )
           for k, v in feature_extractor.__dict__.items():
                  self.assertEqual(UpperCamelCase__     ,  getattr(UpperCamelCase__     ,  UpperCamelCase__     )     )

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

           # Push to hub via save_pretrained
           with tempfile.TemporaryDirectory() as tmp_dir:
                  feature_extractor.save_pretrained(
                      UpperCamelCase__     ,  repo_id="test-feature-extractor"     ,  push_to_hub=UpperCamelCase__     ,  use_auth_token=self._token     )

           lowerCamelCase   :      Union[str, Any]			 =					WavaVecaFeatureExtractor.from_pretrained(F'''{USER}/test-feature-extractor'''     )
           for k, v in feature_extractor.__dict__.items():
                  self.assertEqual(UpperCamelCase__     ,  getattr(UpperCamelCase__     ,  UpperCamelCase__     )     )







    def     _lowercase     (    self     )     ->      Optional[int]:
           lowerCamelCase   :      str			 =					WavaVecaFeatureExtractor.from_pretrained(UpperCamelCase__     )
           feature_extractor.push_to_hub("valid_org/test-feature-extractor"     ,  use_auth_token=self._token     )

           lowerCamelCase   :      Optional[Any]			 =					WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor"     )
           for k, v in feature_extractor.__dict__.items():
                  self.assertEqual(UpperCamelCase__     ,  getattr(UpperCamelCase__     ,  UpperCamelCase__     )     )

           # Reset repo
           delete_repo(token=self._token     ,  repo_id="valid_org/test-feature-extractor"     )

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

           lowerCamelCase   :      Optional[Any]			 =					WavaVecaFeatureExtractor.from_pretrained("valid_org/test-feature-extractor-org"     )
           for k, v in feature_extractor.__dict__.items():
                  self.assertEqual(UpperCamelCase__     ,  getattr(UpperCamelCase__     ,  UpperCamelCase__     )     )







    def     _lowercase     (    self     )     ->      Dict:
           CustomFeatureExtractor.register_for_auto_class()
           lowerCamelCase   :      List[str]			 =					CustomFeatureExtractor.from_pretrained(UpperCamelCase__     )

           feature_extractor.push_to_hub("test-dynamic-feature-extractor"     ,  use_auth_token=self._token     )

           # This has added the proper auto_map field to the config
           self.assertDictEqual(
               feature_extractor.auto_map     ,  {"AutoFeatureExtractor": "custom_feature_extraction.CustomFeatureExtractor"}     ,  )

           lowerCamelCase   :      Union[str, Any]			 =					AutoFeatureExtractor.from_pretrained(
               F'''{USER}/test-dynamic-feature-extractor'''     ,  trust_remote_code=UpperCamelCase__     )
           # Can't make an isinstance check because the new_feature_extractor is from the CustomFeatureExtractor class of a dynamic module
           self.assertEqual(new_feature_extractor.__class__.__name__     ,  "CustomFeatureExtractor"     )












def      A      (      _SCREAMING_SNAKE_CASE = 100_0000    )	-> int:
       lowerCamelCase   :      Tuple			 =					1
       lowerCamelCase   :      int			 =					1
       lowerCamelCase   :      Optional[Any]			 =					{1: 1}

       for inputa in range(2 ,_SCREAMING_SNAKE_CASE    ):
              lowerCamelCase   :      Union[str, Any]			 =					0
              lowerCamelCase   :      List[str]			 =					inputa

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

              if inputa not in counters:
                     lowerCamelCase   :      str			 =					counter

              if counter > pre_counter:
                     lowerCamelCase   :      str			 =					inputa
                     lowerCamelCase   :      Any			 =					counter
       return largest_number


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






