




'''simple docstring'''







import unittest

from transformers.testing_utils import is_torch_available, require_torch, tooslow

from ...generation.test_utils import torch_device
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
						import torch

						from transformers import (
						    CpmAntConfig,
						    CpmAntForCausalLM,
						    CpmAntModel,
						    CpmAntTokenizer,
						)





@require_torch
class      lowerCamelCase_							:




					'''simple docstring'''






					def __init__(    self,  __UpperCamelCase,  __UpperCamelCase=2,  __UpperCamelCase=8,  __UpperCamelCase=True,  __UpperCamelCase=False,  __UpperCamelCase=False,  __UpperCamelCase=False,  __UpperCamelCase=False,  __UpperCamelCase=99,  __UpperCamelCase=32,  __UpperCamelCase=3,  __UpperCamelCase=4,  __UpperCamelCase=37,  __UpperCamelCase=32,  __UpperCamelCase=128,  __UpperCamelCase=8,  __UpperCamelCase=8,  __UpperCamelCase=8,  __UpperCamelCase=1.0,  __UpperCamelCase=True,  ):
							_snake_case	       =       parent
							_snake_case	       =       batch_size
							_snake_case	       =       seq_length
							_snake_case	       =       is_training
							_snake_case	       =       use_token_type_ids
							_snake_case	       =       use_input_mask
							_snake_case	       =       use_labels
							_snake_case	       =       use_mc_token_ids
							_snake_case	       =       vocab_size
							_snake_case	       =       hidden_size
							_snake_case	       =       num_hidden_layers
							_snake_case	       =       num_attention_heads
							_snake_case	       =       intermediate_size
							_snake_case	       =       num_buckets
							_snake_case	       =       max_distance
							_snake_case	       =       prompt_length
							_snake_case	       =       prompt_types
							_snake_case	       =       segment_types
							_snake_case	       =       init_std
							_snake_case	       =       return_dict






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       {}
							_snake_case	       =       ids_tensor([self.batch_size, self.seq_length],  self.vocab_size ).type(torch.intaa )
							_snake_case	       =       False

							_snake_case	       =       self.get_config()

							return (config, input_ids)






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							return CpmAntConfig(
							    vocab_size=self.vocab_size,  hidden_size=self.hidden_size,  num_hidden_layers=self.num_hidden_layers,  num_attention_heads=self.num_attention_heads,  dim_ff=self.intermediate_size,  position_bias_num_buckets=self.num_buckets,  position_bias_max_distance=self.max_distance,  prompt_types=self.prompt_types,  prompt_length=self.prompt_length,  segment_types=self.segment_types,  use_cache=__UpperCamelCase,  init_std=self.init_std,  return_dict=self.return_dict,  )






					def 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase,  __UpperCamelCase,  *__UpperCamelCase ):
							_snake_case	       =       CpmAntModel(config=__UpperCamelCase )
							model.to(__UpperCamelCase )
							model.eval()

							_snake_case	       =       model(**__UpperCamelCase ).last_hidden_state

							self.parent.assertEqual(hidden_states.shape,  (self.batch_size, self.seq_length, config.hidden_size) )






					def 				__SCREAMING_SNAKE_CASE	(    self,  __UpperCamelCase,  __UpperCamelCase,  *__UpperCamelCase ):
							_snake_case	       =       CpmAntForCausalLM(__UpperCamelCase )
							model.to(__UpperCamelCase )
							_snake_case	       =       input_ids["input_ids"].to(__UpperCamelCase )
							model.eval()

							_snake_case	       =       model(**__UpperCamelCase )
							self.parent.assertEqual(
							    model_output.logits.shape,  (self.batch_size, self.seq_length, config.vocab_size + config.prompt_types * config.prompt_length),  )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case       ,    _snake_case	       =       self.prepare_config_and_inputs()
							return config, inputs_dict





@require_torch
class      lowerCamelCase_							(       UpperCAmelCase_,       UpperCAmelCase_,       unittest.TestCase							):




					'''simple docstring'''






					lowercase__    = (CpmAntModel, CpmAntForCausalLM) if is_torch_available() else ()
					lowercase__    = (
					    {"""feature-extraction""": CpmAntModel, """text-generation""": CpmAntForCausalLM} if is_torch_available() else {}
					)

					lowercase__    = False
					lowercase__    = False
					lowercase__    = False
					lowercase__    = False
					lowercase__    = False






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       CpmAntModelTester(self )
							_snake_case	       =       ConfigTester(self,  config_class=__UpperCamelCase )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							self.config_tester.create_and_test_config_common_properties()
							self.config_tester.create_and_test_config_to_json_string()
							self.config_tester.create_and_test_config_to_json_file()
							self.config_tester.create_and_test_config_from_and_save_pretrained()
							self.config_tester.check_config_can_be_init_without_params()
							self.config_tester.check_config_arguments_init()






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							unittest.skip("CPMAnt doesn't support input_embeds." )(self.test_inputs_embeds )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							unittest.skip(
							    "CPMAnt doesn't support retain grad in hidden_states or attentions, because prompt management will peel off the output.hidden_states from graph.\
                 So is attentions. We strongly recommand you use loss to tune model." )(self.test_retain_grad_hidden_states_attentions )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case       ,    _snake_case	       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_cpmant_model(__UpperCamelCase,  __UpperCamelCase )






					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case       ,    _snake_case	       =       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_lm_head_model(__UpperCamelCase,  __UpperCamelCase )





@require_torch
class      lowerCamelCase_							(       unittest.TestCase							):




					'''simple docstring'''






					@tooslow
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       "今天天气真好！"
							_snake_case	       =       "openbmb/cpm-ant-10b"
							_snake_case	       =       CpmAntModel.from_pretrained(__UpperCamelCase )
							_snake_case	       =       CpmAntTokenizer.from_pretrained(__UpperCamelCase )
							_snake_case	       =       tokenizer(__UpperCamelCase,  return_tensors="pt" )
							_snake_case	       =       model(**__UpperCamelCase ).last_hidden_state

							_snake_case	       =       torch.tensor(
							    [[[6.17_08, 5.92_44, 1.08_35], [6.52_07, 6.28_93, -11.33_24], [-1.01_07, -0.05_76, -5.95_77]]],  )
							self.assertTrue(torch.allclose(hidden_states[:, :3, :3],  __UpperCamelCase,  atol=1E-2 ) )





@require_torch
class      lowerCamelCase_							(       unittest.TestCase							):




					'''simple docstring'''






					@tooslow
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       "今天天气真好！"
							_snake_case	       =       "openbmb/cpm-ant-10b"
							_snake_case	       =       CpmAntForCausalLM.from_pretrained(__UpperCamelCase )
							_snake_case	       =       CpmAntTokenizer.from_pretrained(__UpperCamelCase )
							_snake_case	       =       tokenizer(__UpperCamelCase,  return_tensors="pt" )
							_snake_case	       =       model(**__UpperCamelCase ).logits

							_snake_case	       =       torch.tensor(
							    [[[-6.42_67, -6.40_83, -6.39_58], [-5.88_02, -5.94_47, -5.78_11], [-5.38_96, -5.48_20, -5.42_95]]],  )
							self.assertTrue(torch.allclose(hidden_states[:, :3, :3],  __UpperCamelCase,  atol=1E-2 ) )






					@tooslow
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       "openbmb/cpm-ant-10b"
							_snake_case	       =       CpmAntForCausalLM.from_pretrained(__UpperCamelCase )
							_snake_case	       =       CpmAntTokenizer.from_pretrained(__UpperCamelCase )
							_snake_case	       =       "今天天气不错，"
							_snake_case	       =       "今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的"
							_snake_case	       =       tokenizer(__UpperCamelCase,  return_tensors="pt" )
							_snake_case	       =       model.generate(**__UpperCamelCase )
							_snake_case	       =       tokenizer.batch_decode(__UpperCamelCase )
							self.assertEqual(__UpperCamelCase,  __UpperCamelCase )






					@tooslow
					def 				__SCREAMING_SNAKE_CASE	(    self ):
							_snake_case	       =       "openbmb/cpm-ant-10b"
							_snake_case	       =       CpmAntForCausalLM.from_pretrained(__UpperCamelCase )
							_snake_case	       =       CpmAntTokenizer.from_pretrained(__UpperCamelCase )
							_snake_case	       =       ["今天天气不错，", "新年快乐，万事如意！"]
							_snake_case	       =       [
							    "今天天气不错，阳光明媚，我和妈妈一起去超市买东西。\n在超市里，我看到了一个很好玩的玩具，它的名字叫“机器人”。它有一个圆圆的脑袋，两只圆圆的眼睛，还有一个圆圆的",
							    "新年快乐，万事如意！在这辞旧迎新的美好时刻，我谨代表《农村新技术》杂志社全体同仁，向一直以来关心、支持《农村新技术》杂志发展的各级领导、各界朋友和广大读者致以最诚挚的",
							]
							_snake_case	       =       tokenizer(__UpperCamelCase,  return_tensors="pt",  padding=__UpperCamelCase )
							_snake_case	       =       model.generate(**__UpperCamelCase )
							_snake_case	       =       tokenizer.batch_decode(__UpperCamelCase )
							self.assertEqual(__UpperCamelCase,  __UpperCamelCase )











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





