



import inspect
import unittest

from transformers import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
 import torch

 from transformers import MODEL_MAPPING, PoolFormerConfig, PoolFormerForImageClassification, PoolFormerModel
 from transformers.models.poolformer.modeling_poolformer import POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
 from PIL import Image

 from transformers import PoolFormerImageProcessor

class        _A			(      __UpperCAmelCase       ):



       def 						_lowerCamelCase     (						self				:	str):


           '''simple docstring'''

           __a					=							self.config_class(**self.inputs_dict)
           self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''hidden_sizes'''))
           self.parent.assertTrue(hasattr(__SCREAMING_SNAKE_CASE	,						'''num_encoder_blocks'''))


class        _A			:



       def __init__(						self				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	List[str]=13	,						__SCREAMING_SNAKE_CASE				:	int=64	,						__SCREAMING_SNAKE_CASE				:	int=3	,						__SCREAMING_SNAKE_CASE				:	List[str]=4	,						__SCREAMING_SNAKE_CASE				:	Any=[2, 2, 2, 2]	,						__SCREAMING_SNAKE_CASE				:	Tuple=[8, 4, 2, 1]	,						__SCREAMING_SNAKE_CASE				:	Any=[16, 32, 64, 128]	,						__SCREAMING_SNAKE_CASE				:	Optional[Any]=[1, 4, 8, 16]	,						__SCREAMING_SNAKE_CASE				:	Optional[int]=False	,						__SCREAMING_SNAKE_CASE				:	List[str]=True	,						__SCREAMING_SNAKE_CASE				:	Optional[int]="gelu"	,						__SCREAMING_SNAKE_CASE				:	Optional[int]=0.1	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=0.02	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]=3	,						__SCREAMING_SNAKE_CASE				:	List[str]=None	,						):


           '''simple docstring'''

           __a					=							parent
           __a					=							batch_size
           __a					=							image_size
           __a					=							num_channels
           __a					=							num_encoder_blocks
           __a					=							sr_ratios
           __a					=							depths
           __a					=							hidden_sizes
           __a					=							downsampling_rates
           __a					=							is_training
           __a					=							use_labels
           __a					=							hidden_act
           __a					=							hidden_dropout_prob
           __a					=							initializer_range
           __a					=							num_labels
           __a					=							scope



       def 						_lowerCamelCase     (						self				:	Any):


           '''simple docstring'''

           __a					=							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

           __a					=							None
           if self.use_labels:
               __a					=							ids_tensor([self.batch_size, self.image_size, self.image_size]	,						self.num_labels)

           __a					=							PoolFormerConfig(
               image_size=self.image_size	,						num_channels=self.num_channels	,						num_encoder_blocks=self.num_encoder_blocks	,						depths=self.depths	,						hidden_sizes=self.hidden_sizes	,						hidden_act=self.hidden_act	,						hidden_dropout_prob=self.hidden_dropout_prob	,						initializer_range=self.initializer_range	,						)

           return config, pixel_values, labels



       def 						_lowerCamelCase     (						self				:	int	,						__SCREAMING_SNAKE_CASE				:	Union[str, Any]	,						__SCREAMING_SNAKE_CASE				:	str	,						__SCREAMING_SNAKE_CASE				:	str):


           '''simple docstring'''

           __a					=							PoolFormerModel(config=__SCREAMING_SNAKE_CASE)
           model.to(__SCREAMING_SNAKE_CASE)
           model.eval()
           __a					=							model(__SCREAMING_SNAKE_CASE)
           __a					=							__a					=							self.image_size // 32.0
           self.parent.assertEqual(
               result.last_hidden_state.shape	,						(self.batch_size, self.hidden_sizes[-1], expected_height, expected_width))





       def 						_lowerCamelCase     (						self				:	List[Any]):


           '''simple docstring'''

           __a					=							self.prepare_config_and_inputs()
           __a			,  __a			,  __a					=							config_and_inputs
           __a					=							{'''pixel_values''': pixel_values}
           return config, inputs_dict


@require_torch
class        _A			(      __UpperCAmelCase ,__UpperCAmelCase ,unittest.TestCase       ):
       UpperCamelCase__    :       Optional[int]		   =		(PoolFormerModel, PoolFormerForImageClassification) if is_torch_available() else ()
       UpperCamelCase__    :       Any		   =		(
           {'''feature-extraction''': PoolFormerModel, '''image-classification''': PoolFormerForImageClassification}
           if is_torch_available()
           else {}
       )

       UpperCamelCase__    :       str		   =		False
       UpperCamelCase__    :       str		   =		False
       UpperCamelCase__    :       List[str]		   =		False
       UpperCamelCase__    :       Union[str, Any]		   =		False
       UpperCamelCase__    :       List[Any]		   =		False



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           __a					=							PoolFormerModelTester(self)
           __a					=							PoolFormerConfigTester(self	,						config_class=__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           self.config_tester.run_common_tests()



       def 						_lowerCamelCase     (						self				:	int):


           '''simple docstring'''

           __a					=							self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE)



       @unittest.skip('''PoolFormer does not use inputs_embeds''')
       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           pass



       @unittest.skip('''PoolFormer does not have get_input_embeddings method and get_output_embeddings methods''')
       def 						_lowerCamelCase     (						self				:	List[Any]):


           '''simple docstring'''

           pass



       def 						_lowerCamelCase     (						self				:	Union[str, Any]):


           '''simple docstring'''

           def check_hidden_states_output(__SCREAMING_SNAKE_CASE				:	List[str]	,						__SCREAMING_SNAKE_CASE				:	int	,						__SCREAMING_SNAKE_CASE				:	Optional[int]):
               __a					=							model_class(__SCREAMING_SNAKE_CASE)
               model.to(__SCREAMING_SNAKE_CASE)
               model.eval()

               with torch.no_grad():
                   __a					=							model(**self._prepare_for_class(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE))

               __a					=							outputs.hidden_states

               __a					=							self.model_tester.num_encoder_blocks
               self.assertEqual(len(__SCREAMING_SNAKE_CASE)	,						__SCREAMING_SNAKE_CASE)

               # verify the first hidden states (first block)
               self.assertListEqual(
                   list(hidden_states[0].shape[-3:])	,						[
                       self.model_tester.hidden_sizes[0],
                       self.model_tester.image_size // 4,
                       self.model_tester.image_size // 4,
                   ]	,						)

           __a			,  __a					=							self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               __a					=							True
               check_hidden_states_output(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE)

               # check that output_hidden_states also work using config
               del inputs_dict["output_hidden_states"]
               __a					=							True

               check_hidden_states_output(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE)



       def 						_lowerCamelCase     (						self				:	Optional[int]):


           '''simple docstring'''

           if not self.model_tester.is_training:
               return

           __a			,  __a					=							self.model_tester.prepare_config_and_inputs_for_common()
           __a					=							True

           for model_class in self.all_model_classes:
               if model_class in get_values(__SCREAMING_SNAKE_CASE):
                   continue
               __a					=							model_class(__SCREAMING_SNAKE_CASE)
               model.to(__SCREAMING_SNAKE_CASE)
               model.train()
               __a					=							self._prepare_for_class(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						return_labels=__SCREAMING_SNAKE_CASE)
               __a					=							model(**__SCREAMING_SNAKE_CASE).loss
               loss.backward()



       def 						_lowerCamelCase     (						self				:	Dict):


           '''simple docstring'''

           __a			,  __a					=							self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               __a					=							model_class(__SCREAMING_SNAKE_CASE)
               __a					=							inspect.signature(model.forward)
               # signature.parameters is an OrderedDict => so arg_names order is deterministic
               __a					=							[*signature.parameters.keys()]

               __a					=							['''pixel_values''']
               self.assertListEqual(arg_names[:1]	,						__SCREAMING_SNAKE_CASE)





       @slow
       def 						_lowerCamelCase     (						self				:	Tuple):


           '''simple docstring'''

           for model_name in POOLFORMER_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __a					=							PoolFormerModel.from_pretrained(__SCREAMING_SNAKE_CASE)
               self.assertIsNotNone(__SCREAMING_SNAKE_CASE)





def 	__snake_case      (     ):
    __a					=							Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''							)
    return image

@require_torch
class        _A			(      unittest.TestCase       ):



       @slow
       def 						_lowerCamelCase     (						self				:	List[str]):


           '''simple docstring'''

           __a					=							PoolFormerImageProcessor()
           __a					=							PoolFormerForImageClassification.from_pretrained('''sail/poolformer_s12''').to(__SCREAMING_SNAKE_CASE)

           __a					=							image_processor(images=prepare_img()	,						return_tensors='''pt''').to(__SCREAMING_SNAKE_CASE)

           # forward pass
           with torch.no_grad():
               __a					=							model(**__SCREAMING_SNAKE_CASE)

           # verify the logits
           __a					=							torch.Size((1, 1_000))
           self.assertEqual(outputs.logits.shape	,						__SCREAMING_SNAKE_CASE)

           __a					=							torch.tensor([-0.61_13, 0.16_85, -0.04_92]).to(__SCREAMING_SNAKE_CASE)
           self.assertTrue(torch.allclose(outputs.logits[0, :3]	,						__SCREAMING_SNAKE_CASE	,						atol=1E-4))










from __future__ import annotations

__snake_case		:Union[str, Any] 						=	{1: 1}





def 	__snake_case      (     _UpperCAmelCase							):
    if n in COLLATZ_SEQUENCE_LENGTHS:
        return COLLATZ_SEQUENCE_LENGTHS[n]
    __a					=							n // 2 if n % 2 == 0 else 3 * n + 1
    __a					=							collatz_sequence_length(_UpperCAmelCase							) + 1
    __a					=							sequence_length
    return sequence_length





def 	__snake_case      (     _UpperCAmelCase = 1000000							):
    __a					=							max((collatz_sequence_length(_UpperCAmelCase							), i) for i in range(1  ,					_UpperCAmelCase							)							)
    return result[1]


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





