

'''simple docstring'''



import io
import os
import unicodedata
from typing import Any, Dict, List, Optional, Tuple

import sentencepiece as spm

from ...tokenization_utils import PreTrainedTokenizer
from ...utils import logging


__snake_case :	Tuple      						=			logging.get_logger(__name__)

__snake_case :	Optional[Any]      						=			'▁'

__snake_case :	int      						=			{'vocab_file': 'vocab.txt', 'sentencepiece_model_ckpt': 'sentencepiece.bpe.model'}

__snake_case :	List[str]      						=			{
    'sentencepiece_model_file': 'sentencepiece.bpe.model',
    'vocab_file': 'vocab.txt',
}

__snake_case :	List[str]      						=			{
    'vocab_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/vocab.txt',
    },
    'sentencepiece_model_file': {
        'ernie-m-base': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
        'ernie-m-large': 'https://huggingface.co/susnato/ernie-m-base_pytorch/blob/main/sentencepiece.bpe.model',
    },
}

__snake_case :	Any      						=			{
    'ernie-m-base': 514,
    'ernie-m-large': 514,
}

__snake_case :	Optional[Any]      						=			{
    'ernie-m-base': {'do_lower_case': False},
    'ernie-m-large': {'do_lower_case': False},
}



class lowerCamelCase (  lowerCAmelCase__						):



			'''simple docstring'''






			__snake_case    	=       ["input_ids"]

			__snake_case    	=       VOCAB_FILES_NAMES
			__snake_case    	=       PRETRAINED_INIT_CONFIGURATION
			__snake_case    	=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
			__snake_case    	=       PRETRAINED_VOCAB_FILES_MAP
			__snake_case    	=       RESOURCE_FILES_NAMES


			def __init__(      self       :						str		,			lowerCAmelCase_       :						Any		,			lowerCAmelCase_       :						Optional[int]=None		,			lowerCAmelCase_       :						Optional[Any]=False		,			lowerCAmelCase_       :						List[str]="utf8"		,			lowerCAmelCase_       :						List[str]="[UNK]"		,			lowerCAmelCase_       :						Optional[Any]="[SEP]"		,			lowerCAmelCase_       :						Any="[PAD]"		,			lowerCAmelCase_       :						Tuple="[CLS]"		,			lowerCAmelCase_       :						Any="[MASK]"		,			lowerCAmelCase_       :						List[Any] = None		,			**lowerCAmelCase_       :						int		,			)			->		None:





									'''simple docstring'''
									# Mask token behave like a normal word, i.e. include the space before it and
									# is included in the raw text, there should be a match in a non-normalized sentence.

									A__     :   Optional[Any]      ={} if sp_model_kwargs is None else sp_model_kwargs
									super().__init__(
									    do_lower_case=UpperCamelCase__		,			unk_token=UpperCamelCase__		,			sep_token=UpperCamelCase__		,			pad_token=UpperCamelCase__		,			cls_token=UpperCamelCase__		,			mask_token=UpperCamelCase__		,			vocab_file=UpperCamelCase__		,			encoding=UpperCamelCase__		,			sp_model_kwargs=self.sp_model_kwargs		,			**UpperCamelCase__		,			)
									A__     :   str      =do_lower_case
									A__     :   Any      =sentencepiece_model_ckpt
									A__     :   List[Any]      =spm.SentencePieceProcessor(**self.sp_model_kwargs )
									self.sp_model.Load(UpperCamelCase__ )

									# to mimic paddlenlp.transformers.ernie_m.tokenizer.ErnieMTokenizer functioning
									if vocab_file is not None:
															A__     :   str      =self.load_vocab(filepath=UpperCamelCase__ )
									else:
															A__     :   Optional[Any]      ={self.sp_model.id_to_piece(UpperCamelCase__ ): id for id in range(self.sp_model.get_piece_size() )}
									A__     :   str      ={v: k for k, v in self.vocab.items()}


			def lowercase__						(      self       :						Tuple		,			lowerCAmelCase_       :						Optional[int] )			->		List[str]:





									'''simple docstring'''
									if text is None:
															return None

									A__     :   Optional[Any]      =self.tokenize(UpperCamelCase__ )
									A__     :   List[str]      ="", []

									for i, ch in enumerate(UpperCamelCase__ ):
															if ch in self.SP_CHAR_MAPPING:
																					A__     :   List[Any]      =self.SP_CHAR_MAPPING.get(UpperCamelCase__ )
															else:
																					A__     :   Any      =unicodedata.normalize("""NFKC"""		,			UpperCamelCase__ )
															if self.is_whitespace(UpperCamelCase__ ):
																					continue
															normalized_text += ch
															char_mapping.extend([i] * len(UpperCamelCase__ ) )

									A__     :   Dict      =normalized_text, [], 0

									if self.do_lower_case:
															A__     :   Optional[int]      =text.lower()

									for token in split_tokens:
															if token[:1] == "▁":
																					A__     :   Optional[Any]      =token[1:]
															A__     :   Dict      =text[offset:].index(UpperCamelCase__ ) + offset
															A__     :   Union[str, Any]      =start + len(UpperCamelCase__ )

															token_mapping.append((char_mapping[start], char_mapping[end - 1] + 1) )
															A__     :   str      =end
									return token_mapping


			@property
			def lowercase__						(      self       :						List[str] )			->		Any:





									'''simple docstring'''
									return len(self.vocab )


			def lowercase__						(      self       :						str )			->		List[str]:





									'''simple docstring'''
									return dict(self.vocab		,			**self.added_tokens_encoder )


			def __getstate__(      self       :						List[str] )			->		Optional[Any]:





									'''simple docstring'''
									A__     :   Union[str, Any]      =self.__dict__.copy()
									A__     :   Dict      =None
									return state


			def __setstate__(      self       :						List[str]		,			lowerCAmelCase_       :						List[str] )			->		Optional[Any]:





									'''simple docstring'''
									A__     :   Dict      =d

									# for backward compatibility
									if not hasattr(self		,			"""sp_model_kwargs""" ):
															A__     :   List[Any]      ={}

									A__     :   List[Any]      =spm.SentencePieceProcessor(**self.sp_model_kwargs )
									self.sp_model.Load(self.sentencepiece_model_ckpt )


			def lowercase__						(      self       :						Tuple		,			lowerCAmelCase_       :						Union[str, Any] )			->		Dict:





									'''simple docstring'''
									return "".join((self.SP_CHAR_MAPPING.get(UpperCamelCase__		,			UpperCamelCase__ ) for c in text) )


			def lowercase__						(      self       :						Optional[Any]		,			lowerCAmelCase_       :						List[str]		,			lowerCAmelCase_       :						Union[str, Any]=False		,			lowerCAmelCase_       :						List[str]=64		,			lowerCAmelCase_       :						Optional[int]=0.1 )			->		int:





									'''simple docstring'''

									if self.sp_model_kwargs.get("""enable_sampling""" ) is True:
															A__     :   Tuple      =True
									if self.sp_model_kwargs.get("""alpha""" ) is not None:
															A__     :   int      =self.sp_model_kwargs.get("""alpha""" )
									if self.sp_model_kwargs.get("""nbest_size""" ) is not None:
															A__     :   str      =self.sp_model_kwargs.get("""nbest_size""" )

									if not enable_sampling:
															A__     :   Dict      =self.sp_model.EncodeAsPieces(UpperCamelCase__ )
									else:
															A__     :   Optional[int]      =self.sp_model.SampleEncodeAsPieces(UpperCamelCase__		,			UpperCamelCase__		,			UpperCamelCase__ )
									A__     :   Tuple      =[]
									for pi, piece in enumerate(UpperCamelCase__ ):
															if piece == SPIECE_UNDERLINE:
																					if not pieces[pi + 1].startswith(UpperCamelCase__ ) and pi != 0:
																											new_pieces.append(UpperCamelCase__ )
																											continue
																					else:
																											continue
															A__     :   Dict      =0
															for i, chunk in enumerate(UpperCamelCase__ ):
																					if chunk == SPIECE_UNDERLINE:
																											continue
																					if self.is_ch_char(UpperCamelCase__ ) or self.is_punct(UpperCamelCase__ ):
																											if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
																																	new_pieces.append(piece[lst_i:i] )
																											new_pieces.append(UpperCamelCase__ )
																											A__     :   List[Any]      =i + 1
																					elif chunk.isdigit() and i > 0 and not piece[i - 1].isdigit():
																											if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
																																	new_pieces.append(piece[lst_i:i] )
																											A__     :   Any      =i
																					elif not chunk.isdigit() and i > 0 and piece[i - 1].isdigit():
																											if i > lst_i and piece[lst_i:i] != SPIECE_UNDERLINE:
																																	new_pieces.append(piece[lst_i:i] )
																											A__     :   Optional[Any]      =i
															if len(UpperCamelCase__ ) > lst_i:
																					new_pieces.append(piece[lst_i:] )
									return new_pieces


			def lowercase__						(      self       :						Dict		,			lowerCAmelCase_       :						List[str] )			->		Dict:





									'''simple docstring'''
									A__     :   Optional[int]      ="".join(UpperCamelCase__ ).replace(UpperCamelCase__		,			""" """ ).strip()
									return out_string


			def lowercase__						(      self       :						Any		,			lowerCAmelCase_       :						Optional[Any] )			->		Any:





									'''simple docstring'''
									A__     :   Union[str, Any]      =self.convert_ids_to_tokens(UpperCamelCase__ )
									A__     :   Tuple      ="".join(UpperCamelCase__ ).replace(UpperCamelCase__		,			""" """ ).strip()
									return out_string


			def lowercase__						(      self       :						Optional[int]		,			lowerCAmelCase_       :						Tuple )			->		Tuple:





									'''simple docstring'''
									return self.vocab.get(UpperCamelCase__		,			self.vocab.get(self.unk_token ) )


			def lowercase__						(      self       :						Union[str, Any]		,			lowerCAmelCase_       :						Tuple )			->		int:





									'''simple docstring'''
									return self.reverse_vocab.get(UpperCamelCase__		,			self.unk_token )


			def lowercase__						(      self       :						Union[str, Any]		,			lowerCAmelCase_       :						Optional[Any]		,			lowerCAmelCase_       :						List[str]=None )			->		Tuple:





									'''simple docstring'''
									if token_ids_a is None:
															return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
									A__     :   List[str]      =[self.cls_token_id]
									A__     :   Optional[Any]      =[self.sep_token_id]
									return _cls + token_ids_a + _sep + _sep + token_ids_a + _sep


			def lowercase__						(      self       :						Dict		,			lowerCAmelCase_       :						Dict		,			lowerCAmelCase_       :						Union[str, Any]=None )			->		Union[str, Any]:





									'''simple docstring'''
									if offset_mapping_a is None:
															return [(0, 0)] + offset_mapping_a + [(0, 0)]

									return [(0, 0)] + offset_mapping_a + [(0, 0), (0, 0)] + offset_mapping_a + [(0, 0)]


			def lowercase__						(      self       :						str		,			lowerCAmelCase_       :						int		,			lowerCAmelCase_       :						Dict=None		,			lowerCAmelCase_       :						List[Any]=False )			->		str:





									'''simple docstring'''

									if already_has_special_tokens:
															if token_ids_a is not None:
																					raise ValueError(
																					    """You should not supply a second sequence if the provided sequence of """
																					    """ids is already formatted with special tokens for the model.""" )
															return [1 if x in [self.sep_token_id, self.cls_token_id] else 0 for x in token_ids_a]

									if token_ids_a is not None:
															return [1] + ([0] * len(UpperCamelCase__ )) + [1, 1] + ([0] * len(UpperCamelCase__ )) + [1]
									return [1] + ([0] * len(UpperCamelCase__ )) + [1]


			def lowercase__						(      self       :						str		,			lowerCAmelCase_       :						int		,			lowerCAmelCase_       :						List[Any] = None )			->		List[int]:





									'''simple docstring'''
									# called when `add_special_tokens` is True, so align with `build_inputs_with_special_tokens` method
									if token_ids_a is None:
															# [CLS] X [SEP]
															return (len(UpperCamelCase__ ) + 2) * [0]

									# [CLS] A [SEP] [SEP] B [SEP]
									return [0] * (len(UpperCamelCase__ ) + 1) + [1] * (len(UpperCamelCase__ ) + 3)


			def lowercase__						(      self       :						Dict		,			lowerCAmelCase_       :						List[str] )			->		Union[str, Any]:





									'''simple docstring'''
									if "\u4e00" <= char <= "\u9fff":
															return True
									return False


			def lowercase__						(      self       :						str		,			lowerCAmelCase_       :						str )			->		Optional[Any]:





									'''simple docstring'''
									if ("a" <= char <= "z") or ("A" <= char <= "Z"):
															return True
									return False


			def lowercase__						(      self       :						Any		,			lowerCAmelCase_       :						Optional[int] )			->		Any:





									'''simple docstring'''
									if char in ",;:.?!~，；：。？！《》【】":
															return True
									return False


			def lowercase__						(      self       :						Optional[int]		,			lowerCAmelCase_       :						str )			->		int:





									'''simple docstring'''
									if char == " " or char == "\t" or char == "\n" or char == "\r":
															return True
									if len(UpperCamelCase__ ) == 1:
															A__     :   str      =unicodedata.category(UpperCamelCase__ )
															if cat == "Zs":
																					return True
									return False


			def lowercase__						(      self       :						Union[str, Any]		,			lowerCAmelCase_       :						Optional[Any] )			->		Dict:





									'''simple docstring'''
									A__     :   Any      ={}
									with io.open(UpperCamelCase__		,			"""r"""		,			encoding="""utf-8""" ) as f:
															for index, line in enumerate(UpperCamelCase__ ):
																					A__     :   Union[str, Any]      =line.rstrip("""\n""" )
																					A__     :   Union[str, Any]      =int(UpperCamelCase__ )

									return token_to_idx



			def lowercase__						(      self       :						Union[str, Any]		,			lowerCAmelCase_       :						Tuple		,			lowerCAmelCase_       :						List[str] = None )			->		Tuple[str]:





									'''simple docstring'''
									A__     :   Union[str, Any]      =0
									if os.path.isdir(UpperCamelCase__ ):
															A__     :   Optional[Any]      =os.path.join(
															    UpperCamelCase__		,			(filename_prefix + """-""" if filename_prefix else """""") + VOCAB_FILES_NAMES["""vocab_file"""] )
									else:
															A__     :   str      =(filename_prefix + "-" if filename_prefix else "") + save_directory
									with open(UpperCamelCase__		,			"""w"""		,			encoding="""utf-8""" ) as writer:
															for token, token_index in sorted(self.vocab.items()		,			key=lambda lowerCAmelCase_ : kv[1] ):
																					if index != token_index:
																											logger.warning(
																											    f"Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive."
																											    """ Please check that the vocabulary is not corrupted!""" )
																											A__     :   List[Any]      =token_index
																					writer.write(token + """\n""" )
																					index += 1

									A__     :   Union[str, Any]      =os.path.join(UpperCamelCase__		,			"""sentencepiece.bpe.model""" )
									with open(UpperCamelCase__		,			"""wb""" ) as fi:
															A__     :   Any      =self.sp_model.serialized_model_proto()
															fi.write(UpperCamelCase__ )

									return (vocab_file,)







def      A      (      _SCREAMING_SNAKE_CASE = 100_0000    )	-> int:
       lowerCamelCase   :      Tuple			 =					1
       lowerCamelCase   :      int			 =					1
       lowerCamelCase   :      Optional[Any]			 =					{1: 1}

       for inputa in range(2 ,_SCREAMING_SNAKE_CASE    ):
              lowerCamelCase   :      Union[str, Any]			 =					0
              lowerCamelCase   :      List[str]			 =					inputa

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

              if inputa not in counters:
                     lowerCamelCase   :      str			 =					counter

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


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






