


"""simple docstring"""






import os
import tempfile
import unittest
from typing import List

from transformers.models.esm.tokenization_esm import VOCAB_FILES_NAMES, EsmTokenizer
from transformers.testing_utils import require_tokenizers
from transformers.tokenization_utils import PreTrainedTokenizer
from transformers.tokenization_utils_base import PreTrainedTokenizerBase


@require_tokenizers
class 	A_       (     unittest.TestCase   ):





  """simple docstring"""

  lowercase		:	str   =						EsmTokenizer
  def 							lowercase_     (						self						)				->					Dict:
     super().setUp()
     a   :	Any						=    tempfile.mkdtemp()
     # fmt: off
     a   :	List[str]						=    ['<cls>', '<pad>', '<eos>', '<unk>', 'L', 'A', 'G', 'V', 'S', 'E', 'R', 'T', 'I', 'D', 'P', 'K', 'Q', 'N', 'F', 'Y', 'M', 'H', 'W', 'C', 'X', 'B', 'U', 'Z', 'O', '.', '-', '<null_1>', '<mask>']  # noqa: E501
     # fmt: on
     a   :	Optional[int]						=    os.path.join(self.tmpdirname  ,					VOCAB_FILES_NAMES['vocab_file']						)
     with open(self.vocab_file  ,					'w'  ,					encoding='utf-8'						) as vocab_writer:
        vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]						)						)
  def 							lowercase_     (						self  ,					**__UpperCAmelCase						)				->					List[PreTrainedTokenizerBase]:
     return [self.get_tokenizer(**__lowerCamelCase						)]
  def 							lowercase_     (						self  ,					**__UpperCAmelCase						)				->					PreTrainedTokenizer:
     return self.tokenizer_class.from_pretrained(self.tmpdirname  ,					**__lowerCamelCase						)
  def 							lowercase_     (						self						)				->					Optional[int]:
     a   :	Union[str, Any]						=    self.tokenizer_class(self.vocab_file						)

     a   :	int						=    tokenizer.tokenize('LAGVS'						)
     self.assertListEqual(__lowerCamelCase  ,					['L', 'A', 'G', 'V', 'S']						)
     self.assertListEqual(tokenizer.convert_tokens_to_ids(__lowerCamelCase						)  ,					[4, 5, 6, 7, 8]						)
  def 							lowercase_     (						self						)				->					Dict:
     a   :	List[Any]						=    self.tokenizer_class(self.vocab_file						)

     a   :	Any						=    'LAGVS'
     self.assertListEqual(tokenizer.encode(__lowerCamelCase						)  ,					[0, 4, 5, 6, 7, 8, 2]						)
  def 							lowercase_     (						self						)				->					Tuple:
     a   :	List[Any]						=    self.tokenizer_class(self.vocab_file						)

     a   :	Optional[Any]						=    ['LAGVS', 'WCB']
     a   :	Dict						=    tokenizer(__lowerCamelCase  ,					padding=__lowerCamelCase						)['input_ids']

     self.assertListEqual(__lowerCamelCase  ,					[[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2]]						)
  def 							lowercase_     (						self						)				->					List[str]:
     a   :	Any						=    self.tokenizer_class(self.vocab_file						)

     a   :	Optional[Any]						=    ['LAGVS', 'WCB']
     a   :	Optional[Any]						=    tokenizer(__lowerCamelCase  ,					padding=__lowerCamelCase						)['input_ids']

     self.assertListEqual(__lowerCamelCase  ,					[[0, 4, 5, 6, 7, 8, 2], [0, 22, 23, 25, 2, 1, 1]]						)






  def 							lowercase_     (						self						)				->					Dict:
     a   :	Any						=    self.get_tokenizers(fast=__lowerCamelCase						)
     for tokenizer in tokenizers:
        with self.subTest(f'{tokenizer.__class__.__name__}'						):
           a   :	Optional[int]						=    '<unk>'
           a   :	int						=    '<mask>'

           a   :	Tuple						=    tokenizer.tokenize(__lowerCamelCase						)
           a   :	Union[str, Any]						=    tokenizer.tokenize(__lowerCamelCase						)

           self.assertEqual(len(__lowerCamelCase						)  ,					1						)
           self.assertEqual(len(__lowerCamelCase						)  ,					1						)
           self.assertEqual(token_a[0]  ,					__lowerCamelCase						)
           self.assertEqual(token_a[0]  ,					__lowerCamelCase						)













"""simple docstring"""

from __future__ import annotations

lowercase           =							{1: 1}






def _lowerCAmelCase						(	__lowerCamelCase:int ):

						'''simple docstring'''






						if n in COLLATZ_SEQUENCE_LENGTHS:
												return COLLATZ_SEQUENCE_LENGTHS[n]
						__magic_name__      =  n // 2 if n % 2 == 0 else 3 * n + 1
						__magic_name__      =  collatz_sequence_length(__lowerCamelCase ) + 1
						__magic_name__      =  sequence_length
						return sequence_length






def _lowerCAmelCase						(	__lowerCamelCase:int = 1_0_0_0_0_0_0 ):

						'''simple docstring'''






						__magic_name__      =  max((collatz_sequence_length(__lowerCamelCase ), i) for i in range(1			,    __lowerCamelCase ) )
						return result[1]


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



