


'''simple docstring'''




import json
import os
import shutil
import tempfile
import unittest

import numpy as np

from transformers import BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES, BertTokenizer
from transformers.testing_utils import require_tokenizers, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
       from PIL import Image

       from transformers import VisionTextDualEncoderProcessor, ViTImageProcessor

@require_tokenizers
@require_vision
class 		UpperCAmelCase_      (  unittest.TestCase		):





     def 							__UpperCAmelCase      ( self       :      Any    )				->  Any:
        lowerCAmelCase     =			tempfile.mkdtemp()

        # fmt: off
        lowerCAmelCase     =			['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing', ',', 'low', 'lowest']
        # fmt: on
        lowerCAmelCase     =			os.path.join(self.tmpdirname    ,      VOCAB_FILES_NAMES['vocab_file']    )
        with open(self.vocab_file    ,      'w'    ,      encoding='utf-8'    ) as vocab_writer:
           vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]    )    )

        lowerCAmelCase     =			{
            'do_resize': True,
            'size': {'height': 1_8, 'width': 1_8},
            'do_normalize': True,
            'image_mean': [0.5, 0.5, 0.5],
            'image_std': [0.5, 0.5, 0.5],
        }
        lowerCAmelCase     =			os.path.join(self.tmpdirname    ,      UpperCamelCase__    )
        with open(self.image_processor_file    ,      'w'    ,      encoding='utf-8'    ) as fp:
           json.dump(UpperCamelCase__    ,      UpperCamelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    ,      **UpperCAmelCase__       :      List[Any]    )				->  Dict:
        return BertTokenizer.from_pretrained(self.tmpdirname    ,      **UpperCamelCase__    )





     def 							__UpperCAmelCase      ( self       :      Tuple    ,      **UpperCAmelCase__       :      int    )				->  List[str]:
        return ViTImageProcessor.from_pretrained(self.tmpdirname    ,      **UpperCamelCase__    )





     def 							__UpperCAmelCase      ( self       :      str    )				->  Any:
        shutil.rmtree(self.tmpdirname    )





     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  Optional[Any]:
        lowerCAmelCase     =			[np.random.randint(2_5_5    ,      size=(3, 3_0, 4_0_0)    ,      dtype=np.uinta    )]

        lowerCAmelCase     =			[Image.fromarray(np.moveaxis(UpperCamelCase__    ,      0    ,      -1    )    ) for x in image_inputs]

        return image_inputs





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  Tuple:
        lowerCAmelCase     =			self.get_tokenizer()
        lowerCAmelCase     =			self.get_image_processor()

        lowerCAmelCase     =			VisionTextDualEncoderProcessor(tokenizer=UpperCamelCase__    ,      image_processor=UpperCamelCase__    )

        processor.save_pretrained(self.tmpdirname    )
        lowerCAmelCase     =			VisionTextDualEncoderProcessor.from_pretrained(self.tmpdirname    )

        self.assertEqual(processor.tokenizer.get_vocab()    ,      tokenizer.get_vocab()    )
        self.assertIsInstance(processor.tokenizer    ,      (BertTokenizer, BertTokenizerFast)    )

        self.assertEqual(processor.image_processor.to_json_string()    ,      image_processor.to_json_string()    )
        self.assertIsInstance(processor.image_processor    ,      UpperCamelCase__    )





     def 							__UpperCAmelCase      ( self       :      str    )				->  Any:
        lowerCAmelCase     =			VisionTextDualEncoderProcessor(
            tokenizer=self.get_tokenizer()    ,      image_processor=self.get_image_processor()    )
        processor.save_pretrained(self.tmpdirname    )

        lowerCAmelCase     =			self.get_tokenizer(bos_token='(BOS)'    ,      eos_token='(EOS)'    )
        lowerCAmelCase     =			self.get_image_processor(do_normalize=UpperCamelCase__    ,      padding_value=1.0    )

        lowerCAmelCase     =			VisionTextDualEncoderProcessor.from_pretrained(
            self.tmpdirname    ,      bos_token='(BOS)'    ,      eos_token='(EOS)'    ,      do_normalize=UpperCamelCase__    ,      padding_value=1.0    )

        self.assertEqual(processor.tokenizer.get_vocab()    ,      tokenizer_add_kwargs.get_vocab()    )
        self.assertIsInstance(processor.tokenizer    ,      (BertTokenizer, BertTokenizerFast)    )

        self.assertEqual(processor.image_processor.to_json_string()    ,      image_processor_add_kwargs.to_json_string()    )
        self.assertIsInstance(processor.image_processor    ,      UpperCamelCase__    )





     def 							__UpperCAmelCase      ( self       :      Optional[int]    )				->  int:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			VisionTextDualEncoderProcessor(tokenizer=UpperCamelCase__    ,      image_processor=UpperCamelCase__    )

        lowerCAmelCase     =			self.prepare_image_inputs()

        lowerCAmelCase     =			image_processor(UpperCamelCase__    ,      return_tensors='np'    )
        lowerCAmelCase     =			processor(images=UpperCamelCase__    ,      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       :      Dict    )				->  Tuple:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			VisionTextDualEncoderProcessor(tokenizer=UpperCamelCase__    ,      image_processor=UpperCamelCase__    )

        lowerCAmelCase     =			'lower newer'

        lowerCAmelCase     =			processor(text=UpperCamelCase__    )

        lowerCAmelCase     =			tokenizer(UpperCamelCase__    )

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





     def 							__UpperCAmelCase      ( self       :      Dict    )				->  Dict:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			VisionTextDualEncoderProcessor(tokenizer=UpperCamelCase__    ,      image_processor=UpperCamelCase__    )

        lowerCAmelCase     =			'lower newer'
        lowerCAmelCase     =			self.prepare_image_inputs()

        lowerCAmelCase     =			processor(text=UpperCamelCase__    ,      images=UpperCamelCase__    )

        self.assertListEqual(list(inputs.keys()    )    ,      ['input_ids', 'token_type_ids', 'attention_mask', 'pixel_values']    )

        # test if it raises when no input is passed
        with self.assertRaises(UpperCamelCase__    ):
           processor()





     def 							__UpperCAmelCase      ( self       :      Optional[Any]    )				->  Optional[Any]:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			VisionTextDualEncoderProcessor(tokenizer=UpperCamelCase__    ,      image_processor=UpperCamelCase__    )

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

        lowerCAmelCase     =			processor.batch_decode(UpperCamelCase__    )
        lowerCAmelCase     =			tokenizer.batch_decode(UpperCamelCase__    )

        self.assertListEqual(UpperCamelCase__    ,      UpperCamelCase__    )





     def 							__UpperCAmelCase      ( self       :      Tuple    )				->  List[Any]:
        lowerCAmelCase     =			self.get_image_processor()
        lowerCAmelCase     =			self.get_tokenizer()

        lowerCAmelCase     =			VisionTextDualEncoderProcessor(tokenizer=UpperCamelCase__    ,      image_processor=UpperCamelCase__    )

        lowerCAmelCase     =			'lower newer'
        lowerCAmelCase     =			self.prepare_image_inputs()

        lowerCAmelCase     =			processor(text=UpperCamelCase__    ,      images=UpperCamelCase__    )

        self.assertListEqual(list(inputs.keys()    )    ,      processor.model_input_names    )











def __UpperCamelCase			(       _A = 1000000  ):
						lowerCAmelCase_      			=  1
						lowerCAmelCase_      			=  1
						lowerCAmelCase_      			=  {1: 1}

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

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

												if inputa not in counters:
																		lowerCAmelCase_      			=  counter

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


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




