






from ...processing_utils import ProcessorMixin





class 						SCREAMING_SNAKE_CASE				( snake_case					):





							"""simple docstring"""

							A_						  =					"WhisperFeatureExtractor"
							A_						  =					"WhisperTokenizer"

							def __init__(  self:   Tuple		,     __A:   int		,     __A:   int   )    ->				List[str]:
												super().__init__(__A		,     __A   )
												_A								= self.feature_extractor
												_A								= False

							def       __A (  self:   int		,     __A:   Optional[int]=None		,     __A:   Optional[Any]=None		,     __A:   Optional[int]=True   )    ->				List[Any]:
												return self.tokenizer.get_decoder_prompt_ids(task=__A		,     language=__A		,     no_timestamps=__A   )

							def __call__(  self:   Optional[Any]		,     *__A:   Optional[int]		,     **__A:   Optional[Any]   )    ->				Optional[int]:
												# For backward compatibility
												if self._in_target_context_manager:
																	return self.current_processor(*__A		,     **__A   )

												_A								= kwargs.pop('''audio'''		,     __A   )
												_A								= kwargs.pop('''sampling_rate'''		,     __A   )
												_A								= kwargs.pop('''text'''		,     __A   )
												if len(__A   ) > 0:
																	_A								= args[0]
																	_A								= args[1:]

												if audio is None and text is None:
																	raise ValueError('''You need to specify either an `audio` or `text` input to process.'''   )

												if audio is not None:
																	_A								= self.feature_extractor(__A		,     *__A		,     sampling_rate=__A		,     **__A   )
												if text is not None:
																	_A								= self.tokenizer(__A		,     **__A   )

												if text is None:
																	return inputs

												elif audio is None:
																	return encodings
												else:
																	_A								= encodings['''input_ids''']
																	return inputs

							def       __A (  self:   Any		,     *__A:   Optional[Any]		,     **__A:   Any   )    ->				Any:
												return self.tokenizer.batch_decode(*__A		,     **__A   )

							def       __A (  self:   Union[str, Any]		,     *__A:   Dict		,     **__A:   str   )    ->				Any:
												return self.tokenizer.decode(*__A		,     **__A   )



							def       __A (  self:   int		,     __A:   str		,     __A:   Tuple="np"   )    ->				int:
												return self.tokenizer.get_prompt_ids(__A		,     return_tensors=__A   )











def      __A					(     _lowercase = 1_00_00_00 ):

					'''simple docstring'''







					_A								= 1
					_A								= 1
					_A								= {1: 1}

					for inputa in range(2					,			_lowercase ):
										_A								= 0
										_A								= inputa

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

										if inputa not in counters:
															_A								= counter

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


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



