




from collections import OrderedDict
from typing import TYPE_CHECKING, Any, List, Mapping, Optional

from packaging import version


if TYPE_CHECKING:
						from ... import PreTrainedTokenizer, TensorType

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import is_torch_available, logging


_A     =			logging.get_logger(__name__)

_A     =			{
    '''bigscience/bloom''': '''https://huggingface.co/bigscience/bloom/resolve/main/config.json''',
    '''bigscience/bloom-560m''': '''https://huggingface.co/bigscience/bloom-560m/blob/main/config.json''',
    '''bigscience/bloom-1b1''': '''https://huggingface.co/bigscience/bloom-1b1/blob/main/config.json''',
    '''bigscience/bloom-1b7''': '''https://huggingface.co/bigscience/bloom-1b7/blob/main/config.json''',
    '''bigscience/bloom-3b''': '''https://huggingface.co/bigscience/bloom-3b/blob/main/config.json''',
    '''bigscience/bloom-7b1''': '''https://huggingface.co/bigscience/bloom-7b1/blob/main/config.json''',
}


class  A		(  __UpperCAmelCase     ):
		__snake_case									=   'bloom'
		__snake_case									=   ['past_key_values']
		__snake_case									=   {
		    'num_hidden_layers': 'n_layer',
		    'num_attention_heads': 'n_head',
		}



		def __init__(     self,	UpperCamelCase__=25_0880,	UpperCamelCase__=64,	UpperCamelCase__=2,	UpperCamelCase__=8,	UpperCamelCase__=1E-5,	UpperCamelCase__=0.02,	UpperCamelCase__=True,	UpperCamelCase__=1,	UpperCamelCase__=2,	UpperCamelCase__=False,	UpperCamelCase__=0.0,	UpperCamelCase__=0.0,	UpperCamelCase__=1,	UpperCamelCase__=False,	**UpperCamelCase__,	):







								"""simple docstring"""



								lowerCAmelCase_      			=  vocab_size
								# Backward compatibility with n_embed kwarg
								lowerCAmelCase_      			=  kwargs.pop('''n_embed''',	UpperCamelCase__   )
								lowerCAmelCase_      			=  hidden_size if n_embed is None else n_embed
								lowerCAmelCase_      			=  n_layer
								lowerCAmelCase_      			=  n_head
								lowerCAmelCase_      			=  layer_norm_epsilon
								lowerCAmelCase_      			=  initializer_range
								lowerCAmelCase_      			=  use_cache
								lowerCAmelCase_      			=  pretraining_tp
								lowerCAmelCase_      			=  apply_residual_connection_post_layernorm
								lowerCAmelCase_      			=  hidden_dropout
								lowerCAmelCase_      			=  attention_dropout

								lowerCAmelCase_      			=  bos_token_id
								lowerCAmelCase_      			=  eos_token_id
								lowerCAmelCase_      			=  slow_but_exact

								super().__init__(bos_token_id=UpperCamelCase__,	eos_token_id=UpperCamelCase__,	**UpperCamelCase__   )







class  A		(  __UpperCAmelCase     ):
		__snake_case									=   version.parse('1.12'     )



		def __init__(     self,	UpperCamelCase__,	UpperCamelCase__ = "default",	UpperCamelCase__ = None,	UpperCamelCase__ = False,	):







								"""simple docstring"""



								super().__init__(UpperCamelCase__,	task=UpperCamelCase__,	patching_specs=UpperCamelCase__,	use_past=UpperCamelCase__   )
								if not getattr(self._config,	'''pad_token_id''',	UpperCamelCase__   ):
														# TODO: how to do that better?
														lowerCAmelCase_      			=  0



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  OrderedDict({'''input_ids''': {0: '''batch''', 1: '''sequence'''}}   )
								if self.use_past:
														# BLOOM stores values on dynamic axis 2. For more details see: https://github.com/huggingface/transformers/pull/18344
														self.fill_with_past_key_values_(UpperCamelCase__,	direction='''inputs''',	inverted_values_shape=UpperCamelCase__   )
														lowerCAmelCase_      			=  {0: '''batch''', 1: '''past_sequence + sequence'''}
								else:
														lowerCAmelCase_      			=  {0: '''batch''', 1: '''sequence'''}

								return common_inputs



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return self._config.n_layer



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return self._config.n_head



		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return 1E-3



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__ = -1,	UpperCamelCase__ = -1,	UpperCamelCase__ = False,	UpperCamelCase__ = None,	):







								"""simple docstring"""



								lowerCAmelCase_      			=  super(UpperCamelCase__,	self   ).generate_dummy_inputs(
								    UpperCamelCase__,	batch_size=UpperCamelCase__,	seq_length=UpperCamelCase__,	is_pair=UpperCamelCase__,	framework=UpperCamelCase__   )

								# We need to order the input in the way they appears in the forward()
								lowerCAmelCase_      			=  OrderedDict({'''input_ids''': common_inputs['''input_ids''']}   )

								# Need to add the past_keys
								if self.use_past:
														if not is_torch_available():
																				raise ValueError('''Cannot generate dummy past_keys inputs without PyTorch installed.'''   )
														else:
																				import torch

																				lowerCAmelCase_			,					lowerCAmelCase_      			=  common_inputs['''input_ids'''].shape
																				# Not using the same length for past_key_values
																				lowerCAmelCase_      			=  seqlen + 2
																				lowerCAmelCase_      			=  self._config.hidden_size // self.num_attention_heads
																				lowerCAmelCase_      			=  (
																				    batch * self.num_attention_heads,
																				    head_dim,
																				    past_key_values_length,
																				)
																				lowerCAmelCase_      			=  (
																				    batch * self.num_attention_heads,
																				    past_key_values_length,
																				    head_dim,
																				)
																				lowerCAmelCase_      			=  [
																				    (torch.zeros(UpperCamelCase__   ), torch.zeros(UpperCamelCase__   )) for _ in range(self.num_layers   )
																				]

								lowerCAmelCase_      			=  common_inputs['''attention_mask''']
								if self.use_past:
														lowerCAmelCase_      			=  ordered_inputs['''attention_mask'''].dtype
														lowerCAmelCase_      			=  torch.cat(
														    [ordered_inputs['''attention_mask'''], torch.ones(UpperCamelCase__,	UpperCamelCase__,	dtype=UpperCamelCase__   )],	dim=1   )

								return ordered_inputs







		@property
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								return 13










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




