




'''simple docstring'''
import functools
from contextlib import contextmanager

import bert_score
from packaging import version

import datasets
@contextmanager
def 				snake_case_  (   ):



    """simple docstring"""




    def filter_log(a__		:	List[str]			):
        return False if "This IS expected if you are initializing" in record.msg else True

    __lowercase							=						datasets.utils.logging.get_logger("""transformers.modeling_utils"""			)
    logger.addFilter(a__			)
    try:
        yield
    finally:
        logger.removeFilter(a__			)


A							:      Tuple 	=       """\
@inproceedings{bert-score,
  title={BERTScore: Evaluating Text Generation with BERT},
  author={Tianyi Zhang* and Varsha Kishore* and Felix Wu* and Kilian Q. Weinberger and Yoav Artzi},
  booktitle={International Conference on Learning Representations},
  year={2020},
  url={https://openreview.net/forum?id=SkeHuCVFDr}
}
"""

A							:      List[str] 	=       """\
BERTScore leverages the pre-trained contextual embeddings from BERT and matches words in candidate and reference
sentences by cosine similarity.
It has been shown to correlate with human judgment on sentence-level and system-level evaluation.
Moreover, BERTScore computes precision, recall, and F1 measure, which can be useful for evaluating different language
generation tasks.

See the project's README at https://github.com/Tiiiger/bert_score#readme for more information.
"""

A							:      Optional[Any] 	=       """
BERTScore Metrics with the hashcode from a source against one or more references.

Args:
    predictions (list of str): Prediction/candidate sentences.
    references (list of str or list of list of str): Reference sentences.
    lang (str): Language of the sentences; required (e.g. 'en').
    model_type (str): Bert specification, default using the suggested
        model for the target language; has to specify at least one of
        `model_type` or `lang`.
    num_layers (int): The layer of representation to use,
        default using the number of layers tuned on WMT16 correlation data.
    verbose (bool): Turn on intermediate status update.
    idf (bool or dict): Use idf weighting; can also be a precomputed idf_dict.
    device (str): On which the contextual embedding model will be allocated on.
        If this argument is None, the model lives on cuda:0 if cuda is available.
    nthreads (int): Number of threads.
    batch_size (int): Bert score processing batch size,
        at least one of `model_type` or `lang`. `lang` needs to be
        specified when `rescale_with_baseline` is True.
    rescale_with_baseline (bool): Rescale bertscore with pre-computed baseline.
    baseline_path (str): Customized baseline file.
    use_fast_tokenizer (bool): `use_fast` parameter passed to HF tokenizer. New in version 0.3.10.

Returns:
    precision: Precision.
    recall: Recall.
    f1: F1 score.
    hashcode: Hashcode of the library.

Examples:

    >>> predictions = [\"hello there\", \"general kenobi\"]
    >>> references = [\"hello there\", \"general kenobi\"]
    >>> bertscore = datasets.load_metric(\"bertscore\")
    >>> results = bertscore.compute(predictions=predictions, references=references, lang=\"en\")
    >>> print([round(v, 2) for v in results[\"f1\"]])
    [1.0, 1.0]
"""






@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION   ,      _KWARGS_DESCRIPTION     )
class        SCREAMING_SNAKE_CASE(				datasets.Metric     ):

       def     snake_case__			(    self     )    ->					int:

           """simple docstring"""



           return datasets.MetricInfo(
               description=_DESCRIPTION					,		citation=_CITATION					,		homepage="""https://github.com/Tiiiger/bert_score"""					,		inputs_description=_KWARGS_DESCRIPTION					,		features=datasets.Features(
                   {
                       """predictions""": datasets.Value("""string"""					,		id="""sequence"""     ),
                       """references""": datasets.Sequence(datasets.Value("""string"""					,		id="""sequence"""     )					,		id="""references"""     ),
                   }     )					,		codebase_urls=["""https://github.com/Tiiiger/bert_score"""]					,		reference_urls=[
                   """https://github.com/Tiiiger/bert_score""",
                   """https://arxiv.org/abs/1904.09675""",
               ]					,		)

       def     snake_case__			(    self					,		lowerCamelCase__					,		lowerCamelCase__					,		lowerCamelCase__=None					,		lowerCamelCase__=None					,		lowerCamelCase__=None					,		lowerCamelCase__=False					,		lowerCamelCase__=False					,		lowerCamelCase__=None					,		lowerCamelCase__=64					,		lowerCamelCase__=4					,		lowerCamelCase__=False					,		lowerCamelCase__=False					,		lowerCamelCase__=None					,		lowerCamelCase__=False					,		)    ->					List[Any]:

           """simple docstring"""



           __lowercase							=						bert_score.utils.get_hash
           __lowercase							=						bert_score.BERTScorer

           if version.parse(bert_score.__version__     ) >= version.parse("""0.3.10"""     ):
               __lowercase							=						functools.partial(lowerCamelCase__					,		use_fast_tokenizer=lowerCamelCase__     )
               __lowercase							=						functools.partial(lowerCamelCase__					,		use_fast_tokenizer=lowerCamelCase__     )
           elif use_fast_tokenizer:
               raise ImportWarning(
                   """To use a fast tokenizer, the module `bert-score>=0.3.10` is required, and the current version of `bert-score` doesn't match this condition.\n"""
                   """You can install it with `pip install \"bert-score>=0.3.10\"`."""     )

           if model_type is None:
               assert lang is not None, "either lang or model_type should be specified"
               __lowercase							=						bert_score.utils.langamodel[lang.lower()]

           if num_layers is None:
               __lowercase							=						bert_score.utils.modelalayers[model_type]

           __lowercase							=						get_hash(
               model=lowerCamelCase__					,		num_layers=lowerCamelCase__					,		idf=lowerCamelCase__					,		rescale_with_baseline=lowerCamelCase__					,		use_custom_baseline=baseline_path is not None					,		)

           with filter_logging_context():
               if not hasattr(self					,		"""cached_bertscorer"""     ) or self.cached_bertscorer.hash != hashcode:
                   __lowercase							=						scorer(
                       model_type=lowerCamelCase__					,		num_layers=lowerCamelCase__					,		batch_size=lowerCamelCase__					,		nthreads=lowerCamelCase__					,		all_layers=lowerCamelCase__					,		idf=lowerCamelCase__					,		device=lowerCamelCase__					,		lang=lowerCamelCase__					,		rescale_with_baseline=lowerCamelCase__					,		baseline_path=lowerCamelCase__					,		)

           ((__lowercase)				,(__lowercase)				,(__lowercase))							=						self.cached_bertscorer.score(
               cands=lowerCamelCase__					,		refs=lowerCamelCase__					,		verbose=lowerCamelCase__					,		batch_size=lowerCamelCase__					,		)
           __lowercase							=						{
               """precision""": P.tolist(),
               """recall""": R.tolist(),
               """f1""": F.tolist(),
               """hashcode""": hashcode,
           }
           return output_dict

       def     snake_case__			(    self					,		lowerCamelCase__=None					,		lowerCamelCase__=None					,		**lowerCamelCase__     )    ->					Any:

           """simple docstring"""



           if references is not None:
               __lowercase							=						[[ref] if isinstance(lowerCamelCase__					,		lowerCamelCase__     ) else ref for ref in references]
           super().add_batch(predictions=lowerCamelCase__					,		references=lowerCamelCase__					,		**lowerCamelCase__     )




       def     snake_case__			(    self					,		lowerCamelCase__=None					,		lowerCamelCase__=None					,		**lowerCamelCase__     )    ->					Union[str, Any]:

           """simple docstring"""



           if isinstance(lowerCamelCase__					,		lowerCamelCase__     ):
               __lowercase							=						[reference]
           super().add(prediction=lowerCamelCase__					,		reference=lowerCamelCase__					,		**lowerCamelCase__     )










'''simple docstring'''
from __future__ import annotations

A							:      List[str] 	=       {1: 1}
def 				snake_case_  (   a__		:	int			):



    """simple docstring"""




    if n in COLLATZ_SEQUENCE_LENGTHS:
        return COLLATZ_SEQUENCE_LENGTHS[n]
    __lowercase							=						n // 2 if n % 2 == 0 else 3 * n + 1
    __lowercase							=						collatz_sequence_length(a__			) + 1
    __lowercase							=						sequence_length
    return sequence_length
def 				snake_case_  (   a__		:	int = 1_00_00_00			):



    """simple docstring"""




    __lowercase							=						max((collatz_sequence_length(a__			), i) for i in range(1    ,a__			)			)
    return result[1]


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




