




"""simple docstring"""




import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

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


if is_vision_available():
					from PIL import Image

					from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor






@require_vision
class 					__magic_name__							( unittest.TestCase       ):






				'''simple docstring'''





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      tempfile.mkdtemp()

							lowerCamelCase       =      [
							    """[UNK]""",
							    """[CLS]""",
							    """[SEP]""",
							    """[PAD]""",
							    """[MASK]""",
							    """的""",
							    """价""",
							    """格""",
							    """是""",
							    """15""",
							    """便""",
							    """alex""",
							    """##andra""",
							    """，""",
							    """。""",
							    """-""",
							    """t""",
							    """shirt""",
							]
							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""": 224, """width""": 224},
							    """do_center_crop""": True,
							    """crop_size""": {"""height""": 18, """width""": 18},
							    """do_normalize""": True,
							    """image_mean""": [0.48_145_466, 0.4_578_275, 0.40_821_073],
							    """image_std""": [0.26_862_954, 0.26_130_258, 0.27_577_711],
							    """do_convert_rgb""": True,
							}
							lowerCamelCase       =      os.path.join(self.tmpdirname	,				_a				)
							with open(self.image_processor_file	,				"""w"""	,				encoding="""utf-8"""				) as fp:
										json.dump(_a	,				_a				)





				def      _lowerCAmelCase       ( self	,				**_a				):





							"""simple docstring"""
							return BertTokenizer.from_pretrained(self.tmpdirname	,				**_a				)





				def      _lowerCAmelCase       ( self	,				**_a				):





							"""simple docstring"""
							return BertTokenizerFast.from_pretrained(self.tmpdirname	,				**_a				)





				def      _lowerCAmelCase       ( self	,				**_a				):





							"""simple docstring"""
							return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname	,				**_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							shutil.rmtree(self.tmpdirname				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      [np.random.randint(255	,				size=(3, 30, 400)	,				dtype=np.uinta				)]

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

							return image_inputs





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_tokenizer()
							lowerCamelCase       =      self.get_rust_tokenizer()
							lowerCamelCase       =      self.get_image_processor()

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)
							processor_slow.save_pretrained(self.tmpdirname				)
							lowerCamelCase       =      ChineseCLIPProcessor.from_pretrained(self.tmpdirname	,				use_fast=_a				)

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)
							processor_fast.save_pretrained(self.tmpdirname				)
							lowerCamelCase       =      ChineseCLIPProcessor.from_pretrained(self.tmpdirname				)

							self.assertEqual(processor_slow.tokenizer.get_vocab()	,				tokenizer_slow.get_vocab()				)
							self.assertEqual(processor_fast.tokenizer.get_vocab()	,				tokenizer_fast.get_vocab()				)
							self.assertEqual(tokenizer_slow.get_vocab()	,				tokenizer_fast.get_vocab()				)
							self.assertIsInstance(processor_slow.tokenizer	,				_a				)
							self.assertIsInstance(processor_fast.tokenizer	,				_a				)

							self.assertEqual(processor_slow.image_processor.to_json_string()	,				image_processor.to_json_string()				)
							self.assertEqual(processor_fast.image_processor.to_json_string()	,				image_processor.to_json_string()				)
							self.assertIsInstance(processor_slow.image_processor	,				_a				)
							self.assertIsInstance(processor_fast.image_processor	,				_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=self.get_tokenizer()	,				image_processor=self.get_image_processor()				)
							processor.save_pretrained(self.tmpdirname				)

							lowerCamelCase       =      self.get_tokenizer(cls_token="""(CLS)"""	,				sep_token="""(SEP)"""				)
							lowerCamelCase       =      self.get_image_processor(do_normalize=_a				)

							lowerCamelCase       =      ChineseCLIPProcessor.from_pretrained(
							    self.tmpdirname	,				cls_token="""(CLS)"""	,				sep_token="""(SEP)"""	,				do_normalize=_a				)

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

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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_image_processor()
							lowerCamelCase       =      self.get_tokenizer()

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)

							lowerCamelCase       =      self.prepare_image_inputs()

							lowerCamelCase       =      image_processor(_a	,				return_tensors="""np"""				)
							lowerCamelCase       =      processor(images=_a	,				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      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_image_processor()
							lowerCamelCase       =      self.get_tokenizer()

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)

							lowerCamelCase       =      """Alexandra，T-shirt的价格是15便士。"""

							lowerCamelCase       =      processor(text=_a				)

							lowerCamelCase       =      tokenizer(_a				)

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





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_image_processor()
							lowerCamelCase       =      self.get_tokenizer()

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)

							lowerCamelCase       =      """Alexandra，T-shirt的价格是15便士。"""
							lowerCamelCase       =      self.prepare_image_inputs()

							lowerCamelCase       =      processor(text=_a	,				images=_a				)

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

							# test if it raises when no input is passed
							with pytest.raises(_a				):
										processor()





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_image_processor()
							lowerCamelCase       =      self.get_tokenizer()

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)

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

							lowerCamelCase       =      processor.batch_decode(_a				)
							lowerCamelCase       =      tokenizer.batch_decode(_a				)

							self.assertListEqual(_a	,				_a				)





				def      _lowerCAmelCase       ( self				):





							"""simple docstring"""
							lowerCamelCase       =      self.get_image_processor()
							lowerCamelCase       =      self.get_tokenizer()

							lowerCamelCase       =      ChineseCLIPProcessor(tokenizer=_a	,				image_processor=_a				)

							lowerCamelCase       =      """Alexandra，T-shirt的价格是15便士。"""
							lowerCamelCase       =      self.prepare_image_inputs()

							lowerCamelCase       =      processor(text=_a	,				images=_a				)

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









"""simple docstring"""




def 					a__				(       snake_case__ = 1_00_00_00       )		->      int:
			lowerCamelCase       =      1
			lowerCamelCase       =      1
			lowerCamelCase       =      {1: 1}

			for inputa in range(2 ,				snake_case__       ):
						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())))



