






import json
import os
import re
import shutil
import tempfile
import unittest
from typing import Tuple

from transformers import AddedToken, BatchEncoding, ByTaTokenizer
from transformers.utils import cached_property, is_tf_available, is_torch_available

from ...test_tokenization_common import TokenizerTesterMixin


if is_torch_available():
				__A      =				'pt'
elif is_tf_available():
				__A      =				'tf'
else:
				__A      =				'jax'





class 						SCREAMING_SNAKE_CASE				( lowerCAmelCase__  ,	unittest.TestCase					):





							"""simple docstring"""

							A_						  =					ByTaTokenizer
							A_						  =					False

							def       __A (  self:   Dict   )    ->				List[str]:
												super().setUp()
												_A								= ByTaTokenizer()
												tokenizer.save_pretrained(self.tmpdirname   )

							@cached_property
							def       __A (  self:   Tuple   )    ->				Tuple:
												return ByTaTokenizer.from_pretrained('''google/byt5-small'''   )

							def       __A (  self:   int		,     **__A:   Any   )    ->				ByTaTokenizer:
												return self.tokenizer_class.from_pretrained(self.tmpdirname		,     **_lowerCamelCase   )

							def       __A (  self:   List[Any]		,     __A:   Dict		,     __A:   str=False		,     __A:   Any=20		,     __A:   Tuple=5   )    ->				Tuple[str, list]:
												_A								= []
												for i in range(len(_lowerCamelCase   )   ):
																	try:
																						_A								= tokenizer.decode([i]		,     clean_up_tokenization_spaces=_lowerCamelCase   )
																	except UnicodeDecodeError:
																						pass
																	toks.append((i, tok)   )

												_A								= list(filter(lambda __A   : re.match(R'''^[ a-zA-Z]+$'''		,     t[1]   )		,     _lowerCamelCase   )   )
												_A								= list(filter(lambda __A   : [t[0]] == tokenizer.encode(t[1]		,     add_special_tokens=_lowerCamelCase   )		,     _lowerCamelCase   )   )
												if max_length is not None and len(_lowerCamelCase   ) > max_length:
																	_A								= toks[:max_length]
												if min_length is not None and len(_lowerCamelCase   ) < min_length and len(_lowerCamelCase   ) > 0:
																	while len(_lowerCamelCase   ) < min_length:
																						_A								= toks + toks
        # toks_str = [t[1] for t in toks]
												_A								= [t[0] for t in toks]

												# Ensure consistency
												_A								= tokenizer.decode(_lowerCamelCase		,     clean_up_tokenization_spaces=_lowerCamelCase   )
												if " " not in output_txt and len(_lowerCamelCase   ) > 1:
																	_A								= (
																	    tokenizer.decode([toks_ids[0]]		,     clean_up_tokenization_spaces=_lowerCamelCase   )
																	    + ''' '''
																	    + tokenizer.decode(toks_ids[1:]		,     clean_up_tokenization_spaces=_lowerCamelCase   )
																	)
												if with_prefix_space:
																	_A								= ''' ''' + output_txt
												_A								= tokenizer.encode(_lowerCamelCase		,     add_special_tokens=_lowerCamelCase   )
												return output_txt, output_ids

							def       __A (  self:   Dict   )    ->				Any:
												_A								= self.ta_base_tokenizer
												_A								= tokenizer(['''hi</s>''', '''I went to the gym</s>''', '''</s>''']   )
												_A								= tokenizer(['''hi''', '''I went to the gym''', '''''']   )
												self.assertListEqual(batch_with_eos_added['''input_ids''']		,     batch_without_eos_added['''input_ids''']   )

							def       __A (  self:   str   )    ->				Optional[int]:
												_A								= self.ta_base_tokenizer
												_A								= '''Unicode €.'''
												_A								= tokenizer(_lowerCamelCase   )
												_A								= [88, 1_13, 1_08, 1_02, 1_14, 1_03, 1_04, 35, 2_29, 1_33, 1_75, 49, 1]
												self.assertEqual(encoded['''input_ids''']		,     _lowerCamelCase   )

												# decoding
												_A								= tokenizer.decode(_lowerCamelCase   )
												self.assertEqual(_lowerCamelCase		,     '''Unicode €.</s>'''   )

												_A								= tokenizer('''e è é ê ë'''   )
												_A								= [1_04, 35, 1_98, 1_71, 35, 1_98, 1_72, 35, 1_98, 1_73, 35, 1_98, 1_74, 1]
												self.assertEqual(encoded['''input_ids''']		,     _lowerCamelCase   )
												# decoding
												_A								= tokenizer.decode(_lowerCamelCase   )
												self.assertEqual(_lowerCamelCase		,     '''e è é ê ë</s>'''   )

												# encode/decode, but with `encode` instead of `__call__`
												self.assertEqual(tokenizer.decode(tokenizer.encode('''e è é ê ë'''   )   )		,     '''e è é ê ë</s>'''   )

							def       __A (  self:   Union[str, Any]   )    ->				List[Any]:
												_A								= self.ta_base_tokenizer
												_A								= ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
												# fmt: off
												_A								= [68, 35, 1_11, 1_14, 1_13, 1_06, 35, 1_15, 1_00, 1_17, 1_00, 1_06, 1_17, 1_00, 1_15, 1_07, 35, 1_05, 1_14, 1_17, 35, 1_18, 1_20, 1_12, 1_12, 1_00, 1_17, 1_08, 1_25, 1_00, 1_19, 1_08, 1_14, 1_13, 49, 1, 0]
												# fmt: on
												_A								= tokenizer(_lowerCamelCase		,     padding=_lowerCamelCase		,     return_tensors=_lowerCamelCase   )
												self.assertIsInstance(_lowerCamelCase		,     _lowerCamelCase   )

												if FRAMEWORK != "jax":
																	_A								= list(batch.input_ids.numpy()[0]   )
												else:
																	_A								= list(batch.input_ids.tolist()[0]   )

												self.assertListEqual(_lowerCamelCase		,     _lowerCamelCase   )

												self.assertEqual((2, 37)		,     batch.input_ids.shape   )
												self.assertEqual((2, 37)		,     batch.attention_mask.shape   )

							def       __A (  self:   Optional[Any]   )    ->				List[Any]:
												_A								= self.ta_base_tokenizer
												_A								= ['''A long paragraph for summarization.''', '''Another paragraph for summarization.''']
												_A								= tokenizer(_lowerCamelCase		,     padding=_lowerCamelCase		,     return_tensors=_lowerCamelCase   )
												# check if input_ids are returned and no decoder_input_ids
												self.assertIn('''input_ids'''		,     _lowerCamelCase   )
												self.assertIn('''attention_mask'''		,     _lowerCamelCase   )
												self.assertNotIn('''decoder_input_ids'''		,     _lowerCamelCase   )
												self.assertNotIn('''decoder_attention_mask'''		,     _lowerCamelCase   )

							def       __A (  self:   Union[str, Any]   )    ->				int:
												_A								= self.ta_base_tokenizer
												_A								= [
												    '''Summary of the text.''',
												    '''Another summary.''',
												]
												_A								= tokenizer(
												    text_target=_lowerCamelCase		,     max_length=32		,     padding='''max_length'''		,     truncation=_lowerCamelCase		,     return_tensors=_lowerCamelCase   )
												self.assertEqual(32		,     targets['''input_ids'''].shape[1]   )

							def       __A (  self:   Union[str, Any]   )    ->				Optional[int]:
												_A								= self.ta_base_tokenizer
												_A								= ['''A long paragraph for summarization. </s>''']
												_A								= ['''Summary of the text. </s>''']
												# fmt: off
												_A								= [68, 35, 1_11, 1_14, 1_13, 1_06, 35, 1_15, 1_00, 1_17, 1_00, 1_06, 1_17, 1_00, 1_15, 1_07, 35, 1_05, 1_14, 1_17, 35, 1_18, 1_20, 1_12, 1_12, 1_00, 1_17, 1_08, 1_25, 1_00, 1_19, 1_08, 1_14, 1_13, 49, 35, 1]
												_A								= [86, 1_20, 1_12, 1_12, 1_00, 1_17, 1_24, 35, 1_14, 1_05, 35, 1_19, 1_07, 1_04, 35, 1_19, 1_04, 1_23, 1_19, 49, 35, 1]
												# fmt: on

												_A								= tokenizer(_lowerCamelCase		,     text_target=_lowerCamelCase   )

												self.assertEqual(_lowerCamelCase		,     batch['''input_ids'''][0]   )
												self.assertEqual(_lowerCamelCase		,     batch['''labels'''][0]   )

							def       __A (  self:   Optional[Any]   )    ->				List[str]:
												_A								= self.get_tokenizers()
												for tokenizer in tokenizers:
																	with self.subTest(f"""{tokenizer.__class__.__name__}"""   ):
																						self.assertNotEqual(tokenizer.model_max_length		,     42   )

        # Now let's start the test
												_A								= self.get_tokenizers()
												for tokenizer in tokenizers:
																	with self.subTest(f"""{tokenizer.__class__.__name__}"""   ):
																						# Isolate this from the other tests because we save additional tokens/etc
																						_A								= tempfile.mkdtemp()

																						_A								= ''' He is very happy, UNwant\u00E9d,running'''
																						_A								= tokenizer.encode(_lowerCamelCase		,     add_special_tokens=_lowerCamelCase   )
																						tokenizer.save_pretrained(_lowerCamelCase   )

																						_A								= tokenizer.__class__.from_pretrained(_lowerCamelCase   )
																						_A								= after_tokenizer.encode(_lowerCamelCase		,     add_special_tokens=_lowerCamelCase   )
																						self.assertListEqual(_lowerCamelCase		,     _lowerCamelCase   )

																						shutil.rmtree(_lowerCamelCase   )

												_A								= self.get_tokenizers(model_max_length=42   )
												for tokenizer in tokenizers:
																	with self.subTest(f"""{tokenizer.__class__.__name__}"""   ):
																						# Isolate this from the other tests because we save additional tokens/etc
																						_A								= tempfile.mkdtemp()

																						_A								= ''' He is very happy, UNwant\u00E9d,running'''
																						tokenizer.add_tokens(['''bim''', '''bambam''']   )
																						_A								= tokenizer.additional_special_tokens
																						additional_special_tokens.append('''new_additional_special_token'''   )
																						tokenizer.add_special_tokens({'''additional_special_tokens''': additional_special_tokens}   )
																						_A								= tokenizer.encode(_lowerCamelCase		,     add_special_tokens=_lowerCamelCase   )
																						tokenizer.save_pretrained(_lowerCamelCase   )

																						_A								= tokenizer.__class__.from_pretrained(_lowerCamelCase   )
																						_A								= after_tokenizer.encode(_lowerCamelCase		,     add_special_tokens=_lowerCamelCase   )
																						self.assertListEqual(_lowerCamelCase		,     _lowerCamelCase   )
																						self.assertIn('''new_additional_special_token'''		,     after_tokenizer.additional_special_tokens   )
																						self.assertEqual(after_tokenizer.model_max_length		,     42   )

																						_A								= tokenizer.__class__.from_pretrained(_lowerCamelCase		,     model_max_length=43   )
																						self.assertEqual(tokenizer.model_max_length		,     43   )

																						shutil.rmtree(_lowerCamelCase   )

							def       __A (  self:   Optional[Any]   )    ->				str:
												_A								= []
												if self.test_slow_tokenizer:
																	tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())   )

												if self.test_rust_tokenizer:
																	tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())   )

												for tokenizer_class, tokenizer_utils in tokenizer_list:
																	with tempfile.TemporaryDirectory() as tmp_dir:
																						tokenizer_utils.save_pretrained(_lowerCamelCase   )

																						with open(os.path.join(_lowerCamelCase		,     '''special_tokens_map.json'''   )		,     encoding='''utf-8'''   ) as json_file:
																											_A								= json.load(_lowerCamelCase   )

																						with open(os.path.join(_lowerCamelCase		,     '''tokenizer_config.json'''   )		,     encoding='''utf-8'''   ) as json_file:
																											_A								= json.load(_lowerCamelCase   )

																						_A								= [f"""<extra_id_{i}>""" for i in range(1_25   )]

																						_A								= added_tokens_extra_ids + [
																						    '''an_additional_special_token'''
																						]
																						_A								= added_tokens_extra_ids + [
																						    '''an_additional_special_token'''
																						]

																						with open(os.path.join(_lowerCamelCase		,     '''special_tokens_map.json'''   )		,     '''w'''		,     encoding='''utf-8'''   ) as outfile:
																											json.dump(_lowerCamelCase		,     _lowerCamelCase   )
																						with open(os.path.join(_lowerCamelCase		,     '''tokenizer_config.json'''   )		,     '''w'''		,     encoding='''utf-8'''   ) as outfile:
																											json.dump(_lowerCamelCase		,     _lowerCamelCase   )

																						# the following checks allow us to verify that our test works as expected, i.e. that the tokenizer takes
																						# into account the new value of additional_special_tokens given in the "tokenizer_config.json" and
																						# "special_tokens_map.json" files
																						_A								= tokenizer_class.from_pretrained(
																						    _lowerCamelCase		,     )
																						self.assertIn(
																						    '''an_additional_special_token'''		,     tokenizer_without_change_in_init.additional_special_tokens   )
																						# self.assertIn("an_additional_special_token",tokenizer_without_change_in_init.get_vocab()) # ByT5Tokenization no vocab
																						self.assertEqual(
																						    ['''an_additional_special_token''']		,     tokenizer_without_change_in_init.convert_ids_to_tokens(
																						        tokenizer_without_change_in_init.convert_tokens_to_ids(['''an_additional_special_token''']   )   )		,     )

																						# Now we test that we can change the value of additional_special_tokens in the from_pretrained
																						_A								= added_tokens_extra_ids + [AddedToken('''a_new_additional_special_token'''		,     lstrip=_lowerCamelCase   )]
																						_A								= tokenizer_class.from_pretrained(
																						    _lowerCamelCase		,     additional_special_tokens=_lowerCamelCase		,     )

																						self.assertIn('''a_new_additional_special_token'''		,     tokenizer.additional_special_tokens   )
																						self.assertEqual(
																						    ['''a_new_additional_special_token''']		,     tokenizer.convert_ids_to_tokens(
																						        tokenizer.convert_tokens_to_ids(['''a_new_additional_special_token''']   )   )		,     )

							def       __A (  self:   int   )    ->				Optional[Any]:
												_A								= []
												if self.test_slow_tokenizer:
																	tokenizer_list.append((self.tokenizer_class, self.get_tokenizer())   )

												if self.test_rust_tokenizer:
																	tokenizer_list.append((self.rust_tokenizer_class, self.get_rust_tokenizer())   )

												for tokenizer_class, tokenizer_utils in tokenizer_list:
																	with tempfile.TemporaryDirectory() as tmp_dir:
																						tokenizer_utils.save_pretrained(_lowerCamelCase   )

																						_A								= tokenizer_class.from_pretrained(_lowerCamelCase   )

																						self.assertTrue(tokenizer.decode([2_55]   ) == ''''''   )

							def       __A (  self:   Tuple   )    ->				List[str]:
												pass

							def       __A (  self:   Any   )    ->				Union[str, Any]:
												pass

							def       __A (  self:   Tuple   )    ->				List[Any]:
												pass

							def       __A (  self:   Any   )    ->				Union[str, Any]:
												pass

							def       __A (  self:   str   )    ->				str:
												_A								= self.get_tokenizers(fast=_lowerCamelCase		,     do_lower_case=_lowerCamelCase   )
												for tokenizer in tokenizers:
																	with self.subTest(f"""{tokenizer.__class__.__name__}"""   ):
																						_A								= ['''t''', '''h''', '''i''', '''s''', ''' ''', '''i''', '''s''', ''' ''', '''a''', ''' ''', '''t''', '''e''', '''x''', '''t''', '''</s>''']
																						_A								= tokenizer.convert_tokens_to_string(_lowerCamelCase   )

																						self.assertIsInstance(_lowerCamelCase		,     _lowerCamelCase   )



							def       __A (  self:   Dict   )    ->				Any:
												_A								= self.get_tokenizers()
												for tokenizer in tokenizers:
																	with self.subTest(f"""{tokenizer.__class__.__name__}"""   ):
																						_A								= [
																						    '''bos_token''',
																						    '''eos_token''',
																						    '''unk_token''',
																						    '''sep_token''',
																						    '''pad_token''',
																						    '''cls_token''',
																						    '''mask_token''',
																						]

																						_A								= 0
																						_A								= tokenizer.convert_ids_to_tokens(
																						    _lowerCamelCase		,     skip_special_tokens=_lowerCamelCase   )

																						for attr in attributes_list:
																											setattr(_lowerCamelCase		,     attr + '''_id'''		,     _lowerCamelCase   )
																											self.assertEqual(getattr(_lowerCamelCase		,     _lowerCamelCase   )		,     _lowerCamelCase   )
																											self.assertEqual(getattr(_lowerCamelCase		,     attr + '''_id'''   )		,     _lowerCamelCase   )

																											setattr(_lowerCamelCase		,     attr + '''_id'''		,     _lowerCamelCase   )
																											self.assertEqual(getattr(_lowerCamelCase		,     _lowerCamelCase   )		,     _lowerCamelCase   )
																											self.assertEqual(getattr(_lowerCamelCase		,     attr + '''_id'''   )		,     _lowerCamelCase   )

																						setattr(_lowerCamelCase		,     '''additional_special_tokens_ids'''		,     []   )
																						self.assertListEqual(getattr(_lowerCamelCase		,     '''additional_special_tokens'''   )		,     []   )
																						self.assertListEqual(getattr(_lowerCamelCase		,     '''additional_special_tokens_ids'''   )		,     []   )

																						setattr(_lowerCamelCase		,     '''additional_special_tokens_ids'''		,     [token_id_to_test_setters]   )
																						self.assertListEqual(getattr(_lowerCamelCase		,     '''additional_special_tokens'''   )		,     [token_to_test_setters]   )
																						self.assertListEqual(getattr(_lowerCamelCase		,     '''additional_special_tokens_ids'''   )		,     [token_id_to_test_setters]   )












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())))



