





'''simple docstring'''



import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
	from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


_SCREAMING_SNAKE_CASE    =			get_tests_dir('''fixtures/test_sentencepiece.model''')






@require_torch
@require_torchaudio
@require_sentencepiece
class 							__lowercase				(					unittest.TestCase  ):







	'''simple docstring'''

	def   _UpperCAmelCase   (self       )							->							str:







				'''simple docstring'''





				__lowercase   =							tempfile.mkdtemp()

				__lowercase   =							['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
				__lowercase   =							dict(zip(_lowerCamelCase   ,range(len(_lowerCamelCase       )       )       )       )
				__lowercase   =							Path(self.tmpdirname       )
				save_json(_lowerCamelCase   ,save_dir / VOCAB_FILES_NAMES['''vocab_file''']       )
				if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
							copyfile(_lowerCamelCase   ,save_dir / VOCAB_FILES_NAMES['''spm_file''']       )

				__lowercase   =							SpeechaTextTokenizer.from_pretrained(self.tmpdirname       )
				tokenizer.save_pretrained(self.tmpdirname       )

				__lowercase   =							{
				    '''feature_size''': 24,
				    '''num_mel_bins''': 24,
				    '''padding_value''': 0.0,
				    '''sampling_rate''': 16000,
				    '''return_attention_mask''': False,
				    '''do_normalize''': True,
				}
				save_json(_lowerCamelCase   ,save_dir / FEATURE_EXTRACTOR_NAME       )


	def   _UpperCAmelCase   (self   ,**_lowerCamelCase       )							->							Dict:







				'''simple docstring'''





				return SpeechaTextTokenizer.from_pretrained(self.tmpdirname   ,**_lowerCamelCase       )


	def   _UpperCAmelCase   (self   ,**_lowerCamelCase       )							->							Dict:







				'''simple docstring'''





				return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname   ,**_lowerCamelCase       )


	def   _UpperCAmelCase   (self       )							->							Tuple:







				'''simple docstring'''





				shutil.rmtree(self.tmpdirname       )


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







				'''simple docstring'''





				__lowercase   =							self.get_tokenizer()
				__lowercase   =							self.get_feature_extractor()

				__lowercase   =							SpeechaTextProcessor(tokenizer=_lowerCamelCase   ,feature_extractor=_lowerCamelCase       )

				processor.save_pretrained(self.tmpdirname       )
				__lowercase   =							SpeechaTextProcessor.from_pretrained(self.tmpdirname       )

				self.assertEqual(processor.tokenizer.get_vocab()   ,tokenizer.get_vocab()       )
				self.assertIsInstance(processor.tokenizer   ,_lowerCamelCase       )

				self.assertEqual(processor.feature_extractor.to_json_string()   ,feature_extractor.to_json_string()       )
				self.assertIsInstance(processor.feature_extractor   ,_lowerCamelCase       )


	def   _UpperCAmelCase   (self       )							->							Optional[Any]:







				'''simple docstring'''





				__lowercase   =							SpeechaTextProcessor(
				    tokenizer=self.get_tokenizer()   ,feature_extractor=self.get_feature_extractor()       )
				processor.save_pretrained(self.tmpdirname       )

				__lowercase   =							self.get_tokenizer(bos_token='''(BOS)'''   ,eos_token='''(EOS)'''       )
				__lowercase   =							self.get_feature_extractor(do_normalize=_lowerCamelCase   ,padding_value=1.0       )

				__lowercase   =							SpeechaTextProcessor.from_pretrained(
				    self.tmpdirname   ,bos_token='''(BOS)'''   ,eos_token='''(EOS)'''   ,do_normalize=_lowerCamelCase   ,padding_value=1.0       )

				self.assertEqual(processor.tokenizer.get_vocab()   ,tokenizer_add_kwargs.get_vocab()       )
				self.assertIsInstance(processor.tokenizer   ,_lowerCamelCase       )

				self.assertEqual(processor.feature_extractor.to_json_string()   ,feature_extractor_add_kwargs.to_json_string()       )
				self.assertIsInstance(processor.feature_extractor   ,_lowerCamelCase       )


	def   _UpperCAmelCase   (self       )							->							Any:







				'''simple docstring'''





				__lowercase   =							self.get_feature_extractor()
				__lowercase   =							self.get_tokenizer()

				__lowercase   =							SpeechaTextProcessor(tokenizer=_lowerCamelCase   ,feature_extractor=_lowerCamelCase       )

				__lowercase   =							floats_list((3, 1000)       )

				__lowercase   =							feature_extractor(_lowerCamelCase   ,return_tensors='''np'''       )
				__lowercase   =							processor(_lowerCamelCase   ,return_tensors='''np'''       )

				for key in input_feat_extract.keys():
							self.assertAlmostEqual(input_feat_extract[key].sum()   ,input_processor[key].sum()   ,delta=1E-2       )


	def   _UpperCAmelCase   (self       )							->							int:







				'''simple docstring'''





				__lowercase   =							self.get_feature_extractor()
				__lowercase   =							self.get_tokenizer()

				__lowercase   =							SpeechaTextProcessor(tokenizer=_lowerCamelCase   ,feature_extractor=_lowerCamelCase       )

				__lowercase   =							'''This is a test string'''

				__lowercase   =							processor(text=_lowerCamelCase       )

				__lowercase   =							tokenizer(_lowerCamelCase       )

				for key in encoded_tok.keys():
							self.assertListEqual(encoded_tok[key]   ,encoded_processor[key]       )


	def   _UpperCAmelCase   (self       )							->							Any:







				'''simple docstring'''





				__lowercase   =							self.get_feature_extractor()
				__lowercase   =							self.get_tokenizer()

				__lowercase   =							SpeechaTextProcessor(tokenizer=_lowerCamelCase   ,feature_extractor=_lowerCamelCase       )

				__lowercase   =							[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

				__lowercase   =							processor.batch_decode(_lowerCamelCase       )
				__lowercase   =							tokenizer.batch_decode(_lowerCamelCase       )

				self.assertListEqual(_lowerCamelCase   ,_lowerCamelCase       )


	def   _UpperCAmelCase   (self       )							->							int:







				'''simple docstring'''





				__lowercase   =							self.get_feature_extractor()
				__lowercase   =							self.get_tokenizer()

				__lowercase   =							SpeechaTextProcessor(tokenizer=_lowerCamelCase   ,feature_extractor=_lowerCamelCase       )

				self.assertListEqual(
				    processor.model_input_names   ,feature_extractor.model_input_names   ,msg='''`processor` and `feature_extractor` model input names do not match'''   ,)











'''simple docstring'''







from __future__ import annotations

_lowerCamelCase							:						Union[str, Any]								=  {1: 1}






def 		_lowercase		(	lowercase_  ):



		'''simple docstring'''







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






def 		_lowercase		(	lowercase_ = 1000000  ):



		'''simple docstring'''







		_snake_case	       =       max((collatz_sequence_length(lowercase_  ), i) for i in range(1						,							lowercase_  )  )
		return result[1]


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





