




import unittest

from transformers import (
    MODEL_FOR_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
    TextGenerationPipeline,
    logging,
    pipeline,
)
from transformers.testing_utils import (
    CaptureLogger,
    is_pipeline_test,
    require_accelerate,
    require_tf,
    require_torch,
    require_torch_gpu,
    require_torch_or_tf,
)

from .test_pipelines_common import ANY


@is_pipeline_test
@require_torch_or_tf
class  A		(  unittest.TestCase     ):
		__snake_case									=   MODEL_FOR_CAUSAL_LM_MAPPING
		__snake_case									=   TF_MODEL_FOR_CAUSAL_LM_MAPPING



		@require_torch
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  pipeline(task='''text-generation''',	model='''sshleifer/tiny-ctrl''',	framework='''pt'''   )
								# Using `do_sample=False` to force deterministic output
								lowerCAmelCase_      			=  text_generator('''This is a test''',	do_sample=UpperCamelCase__   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        {
								            '''generated_text''': (
								                '''This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'''
								                ''' oscope. FiliFili@@'''
								            )
								        }
								    ],	)

								lowerCAmelCase_      			=  text_generator(['''This is a test''', '''This is a second test''']   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        [
								            {
								                '''generated_text''': (
								                    '''This is a test ☃ ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy oscope.'''
								                    ''' oscope. FiliFili@@'''
								                )
								            }
								        ],
								        [
								            {
								                '''generated_text''': (
								                    '''This is a second test ☃ segmental segmental segmental 议议eski eski flutter flutter Lacy'''
								                    ''' oscope. oscope. FiliFili@@'''
								                )
								            }
								        ],
								    ],	)

								lowerCAmelCase_      			=  text_generator('''This is a test''',	do_sample=UpperCamelCase__,	num_return_sequences=2,	return_tensors=UpperCamelCase__   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        {'''generated_token_ids''': ANY(UpperCamelCase__   )},
								        {'''generated_token_ids''': ANY(UpperCamelCase__   )},
								    ],	)
								lowerCAmelCase_      			=  text_generator.model.config.eos_token_id
								lowerCAmelCase_      			=  '''<pad>'''
								lowerCAmelCase_      			=  text_generator(
								    ['''This is a test''', '''This is a second test'''],	do_sample=UpperCamelCase__,	num_return_sequences=2,	batch_size=2,	return_tensors=UpperCamelCase__,	)
								self.assertEqual(
								    UpperCamelCase__,	[
								        [
								            {'''generated_token_ids''': ANY(UpperCamelCase__   )},
								            {'''generated_token_ids''': ANY(UpperCamelCase__   )},
								        ],
								        [
								            {'''generated_token_ids''': ANY(UpperCamelCase__   )},
								            {'''generated_token_ids''': ANY(UpperCamelCase__   )},
								        ],
								    ],	)



		@require_tf
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  pipeline(task='''text-generation''',	model='''sshleifer/tiny-ctrl''',	framework='''tf'''   )

								# Using `do_sample=False` to force deterministic output
								lowerCAmelCase_      			=  text_generator('''This is a test''',	do_sample=UpperCamelCase__   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        {
								            '''generated_text''': (
								                '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
								                ''' please,'''
								            )
								        }
								    ],	)

								lowerCAmelCase_      			=  text_generator(['''This is a test''', '''This is a second test'''],	do_sample=UpperCamelCase__   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        [
								            {
								                '''generated_text''': (
								                    '''This is a test FeyFeyFey(Croatis.), s.), Cannes Cannes Cannes 閲閲Cannes Cannes Cannes 攵'''
								                    ''' please,'''
								                )
								            }
								        ],
								        [
								            {
								                '''generated_text''': (
								                    '''This is a second test Chieftain Chieftain prefecture prefecture prefecture Cannes Cannes'''
								                    ''' Cannes 閲閲Cannes Cannes Cannes 攵 please,'''
								                )
								            }
								        ],
								    ],	)



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__,	UpperCamelCase__   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  TextGenerationPipeline(model=UpperCamelCase__,	tokenizer=UpperCamelCase__   )
								return text_generator, ["This is a test", "Another test"]



		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  '''Hello I believe in'''
								lowerCAmelCase_      			=  pipeline('''text-generation''',	model='''hf-internal-testing/tiny-random-gpt2'''   )
								lowerCAmelCase_      			=  text_generator(UpperCamelCase__   )
								self.assertEqual(
								    UpperCamelCase__,	[{'''generated_text''': '''Hello I believe in fe fe fe fe fe fe fe fe fe fe fe fe'''}],	)

								lowerCAmelCase_      			=  text_generator(UpperCamelCase__,	stop_sequence=''' fe'''   )
								self.assertEqual(UpperCamelCase__,	[{'''generated_text''': '''Hello I believe in fe'''}]   )



		def        SCREAMING_SNAKE_CASE__			(     self,	UpperCamelCase__,	UpperCamelCase__   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  text_generator.model
								lowerCAmelCase_      			=  text_generator.tokenizer

								lowerCAmelCase_      			=  text_generator('''This is a test'''   )
								self.assertEqual(UpperCamelCase__,	[{'''generated_text''': ANY(UpperCamelCase__   )}]   )
								self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''   )   )

								lowerCAmelCase_      			=  text_generator('''This is a test''',	return_full_text=UpperCamelCase__   )
								self.assertEqual(UpperCamelCase__,	[{'''generated_text''': ANY(UpperCamelCase__   )}]   )
								self.assertNotIn('''This is a test''',	outputs[0]['''generated_text''']   )

								lowerCAmelCase_      			=  pipeline(task='''text-generation''',	model=UpperCamelCase__,	tokenizer=UpperCamelCase__,	return_full_text=UpperCamelCase__   )
								lowerCAmelCase_      			=  text_generator('''This is a test'''   )
								self.assertEqual(UpperCamelCase__,	[{'''generated_text''': ANY(UpperCamelCase__   )}]   )
								self.assertNotIn('''This is a test''',	outputs[0]['''generated_text''']   )

								lowerCAmelCase_      			=  text_generator('''This is a test''',	return_full_text=UpperCamelCase__   )
								self.assertEqual(UpperCamelCase__,	[{'''generated_text''': ANY(UpperCamelCase__   )}]   )
								self.assertTrue(outputs[0]['''generated_text'''].startswith('''This is a test'''   )   )

								lowerCAmelCase_      			=  text_generator(['''This is great !''', '''Something else'''],	num_return_sequences=2,	do_sample=UpperCamelCase__   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        [{'''generated_text''': ANY(UpperCamelCase__   )}, {'''generated_text''': ANY(UpperCamelCase__   )}],
								        [{'''generated_text''': ANY(UpperCamelCase__   )}, {'''generated_text''': ANY(UpperCamelCase__   )}],
								    ],	)

								if text_generator.tokenizer.pad_token is not None:
														lowerCAmelCase_      			=  text_generator(
														    ['''This is great !''', '''Something else'''],	num_return_sequences=2,	batch_size=2,	do_sample=UpperCamelCase__   )
														self.assertEqual(
														    UpperCamelCase__,	[
														        [{'''generated_text''': ANY(UpperCamelCase__   )}, {'''generated_text''': ANY(UpperCamelCase__   )}],
														        [{'''generated_text''': ANY(UpperCamelCase__   )}, {'''generated_text''': ANY(UpperCamelCase__   )}],
														    ],	)

								with self.assertRaises(UpperCamelCase__   ):
														lowerCAmelCase_      			=  text_generator('''test''',	return_full_text=UpperCamelCase__,	return_text=UpperCamelCase__   )
								with self.assertRaises(UpperCamelCase__   ):
														lowerCAmelCase_      			=  text_generator('''test''',	return_full_text=UpperCamelCase__,	return_tensors=UpperCamelCase__   )
								with self.assertRaises(UpperCamelCase__   ):
														lowerCAmelCase_      			=  text_generator('''test''',	return_text=UpperCamelCase__,	return_tensors=UpperCamelCase__   )

								# Empty prompt is slighly special
								# it requires BOS token to exist.
								# Special case for Pegasus which will always append EOS so will
								# work even without BOS.
								if (
								    text_generator.tokenizer.bos_token_id is not None
								    or "Pegasus" in tokenizer.__class__.__name__
								    or "Git" in model.__class__.__name__
								):
														lowerCAmelCase_      			=  text_generator(''''''   )
														self.assertEqual(UpperCamelCase__,	[{'''generated_text''': ANY(UpperCamelCase__   )}]   )
								else:
														with self.assertRaises((ValueError, AssertionError)   ):
																				lowerCAmelCase_      			=  text_generator(''''''   )

								if text_generator.framework == "tf":
														# TF generation does not support max_new_tokens, and it's impossible
														# to control long generation with only max_length without
														# fancy calculation, dismissing tests for now.
														return
								# We don't care about infinite range models.
								# They already work.
								# Skip this test for XGLM, since it uses sinusoidal positional embeddings which are resized on-the-fly.
								lowerCAmelCase_      			=  ['''RwkvForCausalLM''', '''XGLMForCausalLM''', '''GPTNeoXForCausalLM''']
								if (
								    tokenizer.model_max_length < 1_0000
								    and text_generator.model.__class__.__name__ not in EXTRA_MODELS_CAN_HANDLE_LONG_INPUTS
								):
														# Handling of large generations
														with self.assertRaises((RuntimeError, IndexError, ValueError, AssertionError)   ):
																				text_generator('''This is a test''' * 500,	max_new_tokens=20   )

														lowerCAmelCase_      			=  text_generator('''This is a test''' * 500,	handle_long_generation='''hole''',	max_new_tokens=20   )
														# Hole strategy cannot work
														with self.assertRaises(UpperCamelCase__   ):
																				text_generator(
																				    '''This is a test''' * 500,	handle_long_generation='''hole''',	max_new_tokens=tokenizer.model_max_length + 10,	)



		@require_torch
		@require_accelerate
		@require_torch_gpu
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								import torch

								# Classic `model_kwargs`
								lowerCAmelCase_      			=  pipeline(
								    model='''hf-internal-testing/tiny-random-bloom''',	model_kwargs={'''device_map''': '''auto''', '''torch_dtype''': torch.bfloataa},	)
								self.assertEqual(pipe.model.device,	torch.device(0   )   )
								self.assertEqual(pipe.model.lm_head.weight.dtype,	torch.bfloataa   )
								lowerCAmelCase_      			=  pipe('''This is a test'''   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        {
								            '''generated_text''': (
								                '''This is a test test test test test test test test test test test test test test test test'''
								                ''' test'''
								            )
								        }
								    ],	)

								# Upgraded those two to real pipeline arguments (they just get sent for the model as they're unlikely to mean anything else.)
								lowerCAmelCase_      			=  pipeline(model='''hf-internal-testing/tiny-random-bloom''',	device_map='''auto''',	torch_dtype=torch.bfloataa   )
								self.assertEqual(pipe.model.device,	torch.device(0   )   )
								self.assertEqual(pipe.model.lm_head.weight.dtype,	torch.bfloataa   )
								lowerCAmelCase_      			=  pipe('''This is a test'''   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        {
								            '''generated_text''': (
								                '''This is a test test test test test test test test test test test test test test test test'''
								                ''' test'''
								            )
								        }
								    ],	)

								# torch_dtype will be automatically set to float32 if not provided - check: https://github.com/huggingface/transformers/pull/20602
								lowerCAmelCase_      			=  pipeline(model='''hf-internal-testing/tiny-random-bloom''',	device_map='''auto'''   )
								self.assertEqual(pipe.model.device,	torch.device(0   )   )
								self.assertEqual(pipe.model.lm_head.weight.dtype,	torch.floataa   )
								lowerCAmelCase_      			=  pipe('''This is a test'''   )
								self.assertEqual(
								    UpperCamelCase__,	[
								        {
								            '''generated_text''': (
								                '''This is a test test test test test test test test test test test test test test test test'''
								                ''' test'''
								            )
								        }
								    ],	)



		@require_torch
		@require_torch_gpu
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								import torch

								lowerCAmelCase_      			=  pipeline(model='''hf-internal-testing/tiny-random-bloom''',	device=0,	torch_dtype=torch.floataa   )
								pipe('''This is a test'''   )



		@require_torch
		@require_accelerate
		@require_torch_gpu
		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								import torch

								lowerCAmelCase_      			=  pipeline(model='''hf-internal-testing/tiny-random-bloom''',	device_map='''auto''',	torch_dtype=torch.floataa   )
								pipe('''This is a test''',	do_sample=UpperCamelCase__,	top_p=0.5   )







		def        SCREAMING_SNAKE_CASE__			(     self   ):







								"""simple docstring"""



								lowerCAmelCase_      			=  '''Hello world'''
								lowerCAmelCase_      			=  pipeline('''text-generation''',	model='''hf-internal-testing/tiny-random-gpt2'''   )
								if text_generator.model.framework == "tf":
														lowerCAmelCase_      			=  logging.get_logger('''transformers.generation.tf_utils'''   )
								else:
														lowerCAmelCase_      			=  logging.get_logger('''transformers.generation.utils'''   )
								lowerCAmelCase_      			=  '''Both `max_new_tokens`'''  # The beggining of the message to be checked in this test

								# Both are set by the user -> log warning
								with CaptureLogger(UpperCamelCase__   ) as cl:
														lowerCAmelCase_      			=  text_generator(UpperCamelCase__,	max_length=10,	max_new_tokens=1   )
								self.assertIn(UpperCamelCase__,	cl.out   )

								# The user only sets one -> no warning
								with CaptureLogger(UpperCamelCase__   ) as cl:
														lowerCAmelCase_      			=  text_generator(UpperCamelCase__,	max_new_tokens=1   )
								self.assertNotIn(UpperCamelCase__,	cl.out   )

								with CaptureLogger(UpperCamelCase__   ) as cl:
														lowerCAmelCase_      			=  text_generator(UpperCamelCase__,	max_length=10   )
								self.assertNotIn(UpperCamelCase__,	cl.out   )










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




