
from __future__ import annotations

__a							  =						{1: 1}

def    UpperCamelCase_ (	a_		)     ->int:
		if n in COLLATZ_SEQUENCE_LENGTHS:
				return COLLATZ_SEQUENCE_LENGTHS[n]
		A				=n // 2 if n % 2 == 0 else 3 * n + 1
		A				=collatz_sequence_length(a_		) + 1
		A				=sequence_length
		return sequence_length

def    UpperCamelCase_ (	a_ = 100_0000		)     ->int:
		A				=max((collatz_sequence_length(a_		), i) for i in range(1  ,				a_		)		)
		return result[1]


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






import functools
from math import sqrt
from time import time

def    UpperCamelCase_ (	a_  ,				*a_  ,				**a_		)     ->List[Any]:
		A				=time()
		A				=func(*a_  ,				**a_		)
		A				=time()
		if int(end - start		) > 0:
				print(f'''{func.__name__} runtime: {(end - start):0.4f} s'''		)
		else:
				print(f'''{func.__name__} runtime: {(end - start) * 1000:0.4f} ms'''		)
		return output

def    UpperCamelCase_ (	a_		)     ->list[int]:
		if n < 0:
				raise Exception("n is negative"		)
		if n == 0:
				return [0]
		A				=[0, 1]
		for _ in range(n - 1		):
				fib.append(fib[-1] + fib[-2]		)
		return fib

def    UpperCamelCase_ (	a_		)     ->list[int]:

		def fib_recursive_term(a_		) -> int:
				if i < 0:
						raise Exception("n is negative"		)
				if i < 2:
						return i
				return fib_recursive_term(i - 1		) + fib_recursive_term(i - 2		)

		if n < 0:
				raise Exception("n is negative"		)
		return [fib_recursive_term(a_		) for i in range(n + 1		)]

def    UpperCamelCase_ (	a_		)     ->list[int]:

		@functools.cache
		def fib_recursive_term(a_		) -> int:
				if i < 0:
						raise Exception("n is negative"		)
				if i < 2:
						return i
				return fib_recursive_term(i - 1		) + fib_recursive_term(i - 2		)

		if n < 0:
				raise Exception("n is negative"		)
		return [fib_recursive_term(a_		) for i in range(n + 1		)]

def    UpperCamelCase_ (	a_		)     ->list[int]:
		if n < 0:
				raise Exception("n is negative"		)
		# Cache must be outside recursuive function
		# other it will reset every time it calls itself.
		A				={0: 0, 1: 1, 2: 1}  # Prefilled cache

		def rec_fn_memoized(a_		) -> int:
				if num in cache:
						return cache[num]

				A				=rec_fn_memoized(num - 1		) + rec_fn_memoized(num - 2		)
				A				=value
				return value

		return [rec_fn_memoized(a_		) for i in range(n + 1		)]

def    UpperCamelCase_ (	a_		)     ->list[int]:
		if n < 0:
				raise Exception("n is negative"		)
		if n >= 1475:
				raise Exception("n is too large"		)
		A				=sqrt(5		)
		A				=(1 + sqrt_a) / 2
		return [round(phi**i / sqrt_a		) for i in range(n + 1		)]


if __name__ == "__main__":
	__a							  =						3_0
	time_func(fib_iterative, num)
	time_func(fib_recursive, num)  # Around 3s runtime
	time_func(fib_recursive_cached, num)  # Around 0ms runtime
	time_func(fib_memoization, num)
	time_func(fib_binet, num)




