

from dataclasses import dataclass, field
from typing import Optional





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default="""codeparrot/codeparrot"""			,			metadata={"""help""": """Model name or path of model to be trained."""}							)
  _a									=  field(
      default="""./"""			,			metadata={"""help""": """Save dir where model repo is cloned and models updates are saved to."""}							)
  _a									=  field(
      default="""codeparrot/codeparrot-clean-train"""			,			metadata={"""help""": """Name or path of training dataset."""}							)
  _a									=  field(
      default="""codeparrot/codeparrot-clean-valid"""			,			metadata={"""help""": """Name or path of validation dataset."""}							)
  _a									=  field(default=2			,			metadata={"""help""": """Batch size for training."""}							)
  _a									=  field(default=2			,			metadata={"""help""": """Batch size for evaluation."""}							)
  _a									=  field(default=0.1			,			metadata={"""help""": """Value of weight decay."""}							)
  _a									=  field(
      default=10_000			,			metadata={"""help""": """Size of buffer used to shuffle streaming dataset."""}							)
  _a									=  field(default=2e-4			,			metadata={"""help""": """Learning rate fo training."""}							)
  _a									=  field(default="""cosine"""			,			metadata={"""help""": """Learning rate."""}							)
  _a									=  field(
      default=750			,			metadata={"""help""": """Number of warmup steps in the learning rate schedule."""}							)
  _a									=  field(
      default=16			,			metadata={"""help""": """Number of gradient accumulation steps."""}							)
  _a									=  field(
      default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """Use gradient checkpointing to reduce memory footprint."""}							)
  _a									=  field(default=50_000			,			metadata={"""help""": """Maximum number of training steps."""}							)
  _a									=  field(
      default=-1			,			metadata={"""help""": """Maximum number of evaluation steps. If -1 the full dataset is evaluated."""}							)
  _a									=  field(default=1_024			,			metadata={"""help""": """Sequence lengths used for training."""}							)
  _a									=  field(default=1			,			metadata={"""help""": """Training seed."""}							)
  _a									=  field(
      default=1_024			,			metadata={"""help""": """Interval to save checkpoints. Measured as number of forward passes not training steps."""}			,			)
  _a									=  field(
      default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """States path if the training should continue from a checkpoint folder."""}							)
  _a									=  field(default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """If True the data is pretokenized."""}							)





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default="""codeparrot/codeparrot"""			,			metadata={"""help""": """Model name or path of model to be evaluated."""}							)
  _a									=  field(
      default="""codeparrot/codeparrot-clean-valid"""			,			metadata={"""help""": """Name or path of validation dataset."""}							)
  _a									=  field(default=2			,			metadata={"""help""": """Batch size used for evaluation."""}							)
  _a									=  field(
      default=-1			,			metadata={"""help""": """Maximum number of evaluation steps. If -1 the full dataset is evaluated."""}							)
  _a									=  field(default=1_024			,			metadata={"""help""": """Length of sequences to be evaluated."""}							)
  _a									=  field(default=1			,			metadata={"""help""": """Random seed used for evaluation."""}							)





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default="""codeparrot/codeparrot"""			,			metadata={"""help""": """Model name or path of model to be evaluated."""}							)
  _a									=  field(default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """Number of workers used for code evaluation."""}							)
  _a									=  field(
      default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """The number of human-eval tasks to run. If not included all tasks are evaluated."""}			,			)
  _a									=  field(
      default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """Sample from the language model's output distribution."""}							)
  _a									=  field(default=0.2			,			metadata={"""help""": """Sampling temperature used for generation."""}							)
  _a									=  field(default=256			,			metadata={"""help""": """Maximum number of newly generated tokens."""}							)
  _a									=  field(default=0			,			metadata={"""help""": """Top-k parameter used for generation."""}							)
  _a									=  field(default=0.95			,			metadata={"""help""": """Top-p parameter used for nucleus sampling."""}							)
  _a									=  field(default=10			,			metadata={"""help""": """Number of generations to run in parallel."""}							)
  _a									=  field(
      default=200			,			metadata={"""help""": """Number of completions to generate for each sample."""}							)
  _a									=  field(default=1			,			metadata={"""help""": """Random seed used for evaluation."""}							)
  _a									=  field(
      default="""eval_results.json"""			,			metadata={"""help""": """Random seed used for evaluation."""}							)
  _a									=  field(
      default="""0"""			,			metadata={"""help""": """Allow `code_eval` to execute Python code on machine"""}							)
  _a									=  field(
      default=-1			,			metadata={
          """help""": (
              """Determine which device to run the `text-generation` Pipeline on. -1 is CPU and any zero or positive"""
              """ number corresponds to which GPU device id to run on."""
          )
      }			,			)





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default=SCREAMING_SNAKE_CASE			,			metadata={
          """help""": """The number of CPU cores to use for parallel preprocessing. Default uses the maximum available."""
      }			,			)
  _a									=  field(
      default="""transformersbook/codeparrot"""			,			metadata={"""help""": """Folder or name of dataset to process."""}							)
  _a									=  field(
      default="""codeparrot-clean"""			,			metadata={"""help""": """Folder to save processed processed dataset."""}							)
  _a									=  field(
      default=100_000			,			metadata={"""help""": """Number of files to save per JSON output file."""}							)
  _a									=  field(default="""content"""			,			metadata={"""help""": """Column containing text data to process."""}							)
  _a									=  field(
      default=1_000			,			metadata={"""help""": """Maximum line length in file, otherwise file is filtered."""}							)
  _a									=  field(
      default=100			,			metadata={"""help""": """Maximum mean line length in file, otherwise file is filtered."""}							)
  _a									=  field(
      default=0.25			,			metadata={"""help""": """Maximum fraction of non-alphanumeric characters, otherwise file is filtered."""}							)
  _a									=  field(
      default=1.5			,			metadata={"""help""": """Minimum character token ratio for the file, otherwise file is filtered."""}							)
  _a									=  field(
      default=0.7			,			metadata={"""help""": """Probability for filtering config, test and uncommon files."""}							)
  _a									=  field(
      default="""codeparrot/codeparrot"""			,			metadata={"""help""": """Name or path to the tokenizer."""}			,			)
  _a									=  field(
      default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """If True, near-duplicate samples are removed."""}							)
  _a									=  field(
      default=0.85			,			metadata={"""help""": """Jaccard threshold for near-duplicate samples."""}							)





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default="""gpt2"""			,			metadata={"""help""": """Base tokenizer to build new tokenizer from."""}							)
  _a									=  field(
      default="""transformersbook/codeparrot-train"""			,			metadata={"""help""": """Dataset to train tokenizer on."""}							)
  _a									=  field(default="""content"""			,			metadata={"""help""": """Column containing text data to process."""}							)
  _a									=  field(default=200_000			,			metadata={"""help""": """Number of examples to train tokenizer on."""}							)
  _a									=  field(
      default=32_768			,			metadata={"""help""": """Number of examples to train the tokenizer on."""}							)
  _a									=  field(default="""codeparrot"""			,			metadata={"""help""": """Name of new tokenizer."""}							)
  _a									=  field(default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """Push saved tokenizer to the hub."""}							)





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default="""codeparrot/codeparrot"""			,			metadata={"""help""": """Name or path to the tokenizer."""}							)
  _a									=  field(
      default="""codeparrot/codeparrot-clean-train"""			,			metadata={"""help""": """Name or path to the dataset to pretokenize."""}							)
  _a									=  field(
      default="""tokenized-codeparrot-train"""			,			metadata={"""help""": """Repo name of the pretokenized data."""}							)
  _a									=  field(default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """Number of workers used for code evaluation."""}							)





@dataclass
class  __lowerCAmelCase     :
  _a									=  field(
      default="""gpt2-large"""			,			metadata={"""help""": """Configuration to use for model initialization."""}							)
  _a									=  field(
      default="""codeparrot/codeparrot"""			,			metadata={"""help""": """Tokenizer attached to model."""}							)
  _a									=  field(default="""codeparrot"""			,			metadata={"""help""": """Name of the created model."""}							)
  _a									=  field(default=SCREAMING_SNAKE_CASE			,			metadata={"""help""": """Push saved tokenizer to the hub."""}							)





def      a      (			A__	:   int = 1000000     )    ->      int:





      """simple docstring"""



      _lowercase	       =1
      _lowercase	       =1
      _lowercase	       ={1: 1}

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

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

            if inputa not in counters:
                  _lowercase	       =counter

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


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


