


import argparse
from pathlib import Path

from transformers import AutoConfig, AutoTokenizer, RagConfig, RagSequenceForGeneration, RagTokenForGeneration



def 			lowerCAmelCase (		lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ ,   lowerCAmelCase_ = None ,   lowerCAmelCase_ = None ,   lowerCAmelCase_ = None ,   )-> Tuple:
				if config_name_or_path is None:
								lowerCAmelCase_ :      str    				=				'''facebook/rag-token-base''' if model_type == '''rag_token''' else '''facebook/rag-sequence-base'''

				if generator_tokenizer_name_or_path is None:
								lowerCAmelCase_ :      Optional[int]    				=				generator_name_or_path

				if question_encoder_tokenizer_name_or_path is None:
								lowerCAmelCase_ :      List[Any]    				=				question_encoder_name_or_path

				lowerCAmelCase_ :      Dict    				=				RagTokenForGeneration if model_type == '''rag_token''' else RagSequenceForGeneration

				# Save model.
				lowerCAmelCase_ :      str    				=				RagConfig.from_pretrained(lowerCAmelCase_ )
				lowerCAmelCase_ :      List[Any]    				=				AutoConfig.from_pretrained(lowerCAmelCase_ )
				lowerCAmelCase_ :      Dict    				=				AutoConfig.from_pretrained(lowerCAmelCase_ )

				lowerCAmelCase_ :      Optional[Any]    				=				gen_config
				lowerCAmelCase_ :      Any    				=				question_encoder_config

				lowerCAmelCase_ :      List[Any]    				=				model_class.from_pretrained_question_encoder_generator(
				    lowerCAmelCase_ ,   lowerCAmelCase_ ,   config=lowerCAmelCase_ )
				rag_model.save_pretrained(lowerCAmelCase_ )

				# Sanity check.
				model_class.from_pretrained(lowerCAmelCase_ )

				# Save tokenizers.
				lowerCAmelCase_ :      int    				=				AutoTokenizer.from_pretrained(lowerCAmelCase_ )
				gen_tokenizer.save_pretrained(dest_dir / '''generator_tokenizer/''' )
				lowerCAmelCase_ :      Optional[Any]    				=				AutoTokenizer.from_pretrained(lowerCAmelCase_ )
				question_encoder_tokenizer.save_pretrained(dest_dir / '''question_encoder_tokenizer/''' )


if __name__ == "__main__":
						_UpperCAmelCase			:  List[Any]     =argparse.ArgumentParser()
						parser.add_argument(
						    """--model_type""",
						    choices=["""rag_sequence""", """rag_token"""],
						    required=True,
						    type=str,
						    help="""RAG model type: rag_sequence, rag_token""",
						)
						parser.add_argument("""--dest""", type=str, required=True, help="""Path to the output checkpoint directory.""")
						parser.add_argument("""--generator_name_or_path""", type=str, required=True, help="""Generator model identifier""")
						parser.add_argument(
						    """--question_encoder_name_or_path""", type=str, required=True, help="""Question encoder model identifier"""
						)

						parser.add_argument(
						    """--generator_tokenizer_name_or_path""",
						    type=str,
						    help="""Generator tokenizer identifier, if not specified, resolves to ``generator_name_or_path``""",
						)
						parser.add_argument(
						    """--question_encoder_tokenizer_name_or_path""",
						    type=str,
						    help="""Question encoder tokenizer identifier, if not specified, resolves to ``question_encoder_name_or_path``""",
						)
						parser.add_argument(
						    """--config_name_or_path""",
						    type=str,
						    help=(
						        """Identifier of the model config to use, if not provided, resolves to a base config for a given"""
						        """ ``model_type``"""
						    ),
						)

						_UpperCAmelCase			:  Optional[int]     =parser.parse_args()

						_UpperCAmelCase			:  Any     =Path(args.dest)
						dest_dir.mkdir(exist_ok=True)

						consolidate(
						    args.model_type,
						    args.generator_name_or_path,
						    args.question_encoder_name_or_path,
						    dest_dir,
						    args.config_name_or_path,
						    args.generator_tokenizer_name_or_path,
						    args.question_encoder_tokenizer_name_or_path,
						)



def 			lowerCAmelCase (		lowerCAmelCase_ = 1_000_000 )-> int:
				lowerCAmelCase_ :      Dict    				=				1
				lowerCAmelCase_ :      List[Any]    				=				1
				lowerCAmelCase_ :      Optional[Any]    				=				{1: 1}

				for inputa in range(2 ,   lowerCAmelCase_ ):
								lowerCAmelCase_ :      Tuple    				=				0
								lowerCAmelCase_ :      Dict    				=				inputa

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

								if inputa not in counters:
												lowerCAmelCase_ :      Tuple    				=				counter

								if counter > pre_counter:
												lowerCAmelCase_ :      Optional[int]    				=				inputa
												lowerCAmelCase_ :      Union[str, Any]    				=				counter
				return largest_number


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