





"""simple docstring"""




import re
import string

import numpy as np

import datasets


lowerCAmelCase							:    Optional[Any]  							=							"""
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
"""

lowerCAmelCase							:    Tuple  							=							"""
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results[\"exact_match\"], 1))
    25.0

    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results[\"exact_match\"], 1))
    50.0


    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results[\"exact_match\"], 1))
    75.0

    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"the cat\", \"theater\", \"YELLING\", \"agent007\"]
    >>> preds = [\"cat?\", \"theater\", \"yelling\", \"agent\"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=[\"the \", \"yell\", \"YELL\"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results[\"exact_match\"], 1))
    100.0

    >>> exact_match = datasets.load_metric(\"exact_match\")
    >>> refs = [\"The cat sat on the mat.\", \"Theaters are great.\", \"It's like comparing oranges and apples.\"]
    >>> preds = [\"The cat sat on the mat?\", \"Theaters are great.\", \"It's like comparing apples and oranges.\"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results[\"exact_match\"], 1))
    33.3

"""

lowerCAmelCase							:    Dict  							=							"""
"""






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






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							return datasets.MetricInfo(
							    description=_DESCRIPTION	,				citation=_CITATION	,				inputs_description=_KWARGS_DESCRIPTION	,				features=datasets.Features(
							        {
							            """predictions""": datasets.Value("""string"""	,				id="""sequence"""				),
							            """references""": datasets.Value("""string"""	,				id="""sequence"""				),
							        }				)	,				reference_urls=[]	,				)





				def      _lowerCAmelCase       ( self	,				_a	,				_a	,				_a=None	,				_a=False	,				_a=False	,				_a=False	,				):





							"""simple docstring"""
							if regexes_to_ignore is not None:
										for s in regexes_to_ignore:
													lowerCamelCase       =      np.array([re.sub(_a	,				""""""	,				_a				) for x in predictions]				)
													lowerCamelCase       =      np.array([re.sub(_a	,				""""""	,				_a				) for x in references]				)
							else:
										lowerCamelCase       =      np.asarray(_a				)
										lowerCamelCase       =      np.asarray(_a				)

							if ignore_case:
										lowerCamelCase       =      np.char.lower(_a				)
										lowerCamelCase       =      np.char.lower(_a				)

							if ignore_punctuation:
										lowerCamelCase       =      string.punctuation.maketrans(""""""	,				""""""	,				string.punctuation				)
										lowerCamelCase       =      np.char.translate(_a	,				table=_a				)
										lowerCamelCase       =      np.char.translate(_a	,				table=_a				)

							if ignore_numbers:
										lowerCamelCase       =      string.digits.maketrans(""""""	,				""""""	,				string.digits				)
										lowerCamelCase       =      np.char.translate(_a	,				table=_a				)
										lowerCamelCase       =      np.char.translate(_a	,				table=_a				)

							lowerCamelCase       =      predictions == references

							return {"exact_match": np.mean(_a				) * 100}









"""simple docstring"""




def 					a__				(       snake_case__ = 1_00_00_00       )		->      int:
			lowerCamelCase       =      1
			lowerCamelCase       =      1
			lowerCamelCase       =      {1: 1}

			for inputa in range(2 ,				snake_case__       ):
						lowerCamelCase       =      0
						lowerCamelCase       =      inputa

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

						if inputa not in counters:
									lowerCamelCase       =      counter

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


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



