

'''simple docstring'''


from __future__ import annotations

import inspect
import unittest
from typing import List, Tuple

from transformers import RegNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers import TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST, TFRegNetForImageClassification, TFRegNetModel


if is_vision_available():
					from PIL import Image

					from transformers import AutoImageProcessor




class     a			:






						"""simple docstring"""




						def __init__(							self					:      str			,			snake_case_					:      str			,			snake_case_					:      Union[str, Any]=3			,			snake_case_					:      Any=3_2			,			snake_case_					:      List[Any]=3			,			snake_case_					:      Optional[Any]=1_0			,			snake_case_					:      Optional[Any]=[1_0, 2_0, 3_0, 4_0]			,			snake_case_					:      int=[1, 1, 2, 1]			,			snake_case_					:      Any=True			,			snake_case_					:      Dict=True			,			snake_case_					:      Any="relu"			,			snake_case_					:      Union[str, Any]=3			,			snake_case_					:      Dict=None			,			):



								'''simple docstring'''



								snake_case__						:       Any       						=  parent
								snake_case__						:       Optional[int]       						=  batch_size
								snake_case__						:       Optional[int]       						=  image_size
								snake_case__						:       Optional[int]       						=  num_channels
								snake_case__						:       List[Any]       						=  embeddings_size
								snake_case__						:       int       						=  hidden_sizes
								snake_case__						:       str       						=  depths
								snake_case__						:       Dict       						=  is_training
								snake_case__						:       str       						=  use_labels
								snake_case__						:       int       						=  hidden_act
								snake_case__						:       List[Any]       						=  num_labels
								snake_case__						:       List[Any]       						=  scope
								snake_case__						:       int       						=  len(snake_case_  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								snake_case__						:       Dict       						=  None
								if self.use_labels:
										snake_case__						:       int       						=  ids_tensor([self.batch_size]			,			self.num_labels  )

								snake_case__						:       List[Any]       						=  self.get_config()
								return config, pixel_values, labels







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								return RegNetConfig(
								    num_channels=self.num_channels			,			embeddings_size=self.embeddings_size			,			hidden_sizes=self.hidden_sizes			,			depths=self.depths			,			hidden_act=self.hidden_act			,			num_labels=self.num_labels			,			)







						def       __magic_name__							(							self					:      Dict			,			snake_case_					:      List[Any]			,			snake_case_					:      Any			,			snake_case_					:      int  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  TFRegNetModel(config=snake_case_  )
								snake_case__						:       Tuple       						=  model(snake_case_			,			training=snake_case_  )
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape			,			(self.batch_size, self.hidden_sizes[-1], self.image_size // 3_2, self.image_size // 3_2)			,			)







						def       __magic_name__							(							self					:      Dict			,			snake_case_					:      List[Any]			,			snake_case_					:      Any			,			snake_case_					:      int  ):



								'''simple docstring'''



								snake_case__						:       Tuple       						=  self.num_labels
								snake_case__						:       Union[str, Any]       						=  TFRegNetForImageClassification(snake_case_  )
								snake_case__						:       Optional[Any]       						=  model(snake_case_			,			labels=snake_case_			,			training=snake_case_  )
								self.parent.assertEqual(result.logits.shape			,			(self.batch_size, self.num_labels)  )







						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       Optional[Any]       						=  self.prepare_config_and_inputs()
								snake_case__						,       snake_case__						,       snake_case__						:       List[Any]       						=  config_and_inputs
								snake_case__						:       Optional[int]       						=  {'''pixel_values''': pixel_values}
								return config, inputs_dict





@require_tf
class     a			(				SCREAMING_SNAKE_CASE			,			SCREAMING_SNAKE_CASE			,			unittest.TestCase       ):






						"""simple docstring"""




						__UpperCAmelCase			     =    (TFRegNetModel, TFRegNetForImageClassification) if is_tf_available() else ()
						__UpperCAmelCase			     =    (
						    {"""feature-extraction""": TFRegNetModel, """image-classification""": TFRegNetForImageClassification}
						    if is_tf_available()
						    else {}
						)

						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False
						__UpperCAmelCase			     =    False







						def       __magic_name__							(							self					:      str  ):



								'''simple docstring'''



								snake_case__						:       int       						=  TFRegNetModelTester(self  )
								snake_case__						:       Dict       						=  ConfigTester(self			,			config_class=snake_case_			,			has_text_modality=snake_case_  )







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



								'''simple docstring'''



								return







						@unittest.skip(reason='''RegNet does not use inputs_embeds'''  )
						def       __magic_name__							(							self					:      Union[str, Any]  ):



								'''simple docstring'''



								pass







						@unittest.skipIf(
						    not is_tf_available() or len(tf.config.list_physical_devices('''GPU'''  )  ) == 0			,			reason='''TF does not support backprop for grouped convolutions on CPU.'''			,			)
						@slow
						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								super().test_keras_fit()







						@unittest.skip(reason='''RegNet does not support input and output embeddings'''  )
						def       __magic_name__							(							self					:      Optional[int]  ):



								'''simple docstring'''



								pass







						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case__						:       str       						=  model_class(snake_case_  )
										snake_case__						:       Union[str, Any]       						=  inspect.signature(model.call  )
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										snake_case__						:       Union[str, Any]       						=  [*signature.parameters.keys()]

										snake_case__						:       Optional[Any]       						=  ['''pixel_values''']
										self.assertListEqual(arg_names[:1]			,			snake_case_  )







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



								'''simple docstring'''



								snake_case__						:       str       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*snake_case_  )







						def       __magic_name__							(							self					:      Tuple  ):



								'''simple docstring'''



								def check_hidden_states_output(snake_case_					:      Tuple			,			snake_case_					:      Tuple			,			snake_case_					:      int  ):
										snake_case__						:       List[str]       						=  model_class(snake_case_  )
										snake_case__						:       Union[str, Any]       						=  model(**self._prepare_for_class(snake_case_			,			snake_case_  )			,			training=snake_case_  )

										snake_case__						:       Union[str, Any]       						=  outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

										snake_case__						:       Optional[Any]       						=  self.model_tester.num_stages
										self.assertEqual(len(snake_case_  )			,			expected_num_stages + 1  )

										# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
										self.assertListEqual(
										    list(hidden_states[0].shape[-2:]  )			,			[self.model_tester.image_size // 2, self.model_tester.image_size // 2]			,			)

								snake_case__						,       snake_case__						:       Tuple       						=  self.model_tester.prepare_config_and_inputs_for_common()
								snake_case__						:       Optional[int]       						=  ['''basic''', '''bottleneck''']
								for model_class in self.all_model_classes:
										for layer_type in layers_type:
												snake_case__						:       int       						=  layer_type
												snake_case__						:       int       						=  True
												check_hidden_states_output(snake_case_			,			snake_case_			,			snake_case_  )

												# check that output_hidden_states also work using config
												del inputs_dict["output_hidden_states"]
												snake_case__						:       Union[str, Any]       						=  True

												check_hidden_states_output(snake_case_			,			snake_case_			,			snake_case_  )







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						,       snake_case__						:       Union[str, Any]       						=  self.model_tester.prepare_config_and_inputs_for_common()

								def check_equivalence(snake_case_					:      Dict			,			snake_case_					:      int			,			snake_case_					:      Union[str, Any]			,			snake_case_					:      List[Any]={}  ):
										snake_case__						:       Dict       						=  model(snake_case_			,			return_dict=snake_case_			,			**snake_case_  )
										snake_case__						:       Optional[int]       						=  model(snake_case_			,			return_dict=snake_case_			,			**snake_case_  ).to_tuple()

										def recursive_check(snake_case_					:      int			,			snake_case_					:      Optional[Any]  ):
												if isinstance(snake_case_			,			(List, Tuple)  ):
														for tuple_iterable_value, dict_iterable_value in zip(snake_case_			,			snake_case_  ):
																recursive_check(snake_case_			,			snake_case_  )
												elif tuple_object is None:
														return
												else:
														self.assertTrue(
														    all(tf.equal(snake_case_			,			snake_case_  )  )			,			msg=(
														        '''Tuple and dict output are not equal. Difference:'''
														        F""" {tf.math.reduce_max(tf.abs(tuple_object - dict_object  )  )}"""
														    )			,			)

												recursive_check(snake_case_			,			snake_case_  )

								for model_class in self.all_model_classes:
										snake_case__						:       List[Any]       						=  model_class(snake_case_  )

										snake_case__						:       Optional[int]       						=  self._prepare_for_class(snake_case_			,			snake_case_  )
										snake_case__						:       List[Any]       						=  self._prepare_for_class(snake_case_			,			snake_case_  )
										check_equivalence(snake_case_			,			snake_case_			,			snake_case_  )

										snake_case__						:       Optional[int]       						=  self._prepare_for_class(snake_case_			,			snake_case_			,			return_labels=snake_case_  )
										snake_case__						:       Optional[Any]       						=  self._prepare_for_class(snake_case_			,			snake_case_			,			return_labels=snake_case_  )
										check_equivalence(snake_case_			,			snake_case_			,			snake_case_  )

										snake_case__						:       List[str]       						=  self._prepare_for_class(snake_case_			,			snake_case_  )
										snake_case__						:       Union[str, Any]       						=  self._prepare_for_class(snake_case_			,			snake_case_  )
										check_equivalence(snake_case_			,			snake_case_			,			snake_case_			,			{'''output_hidden_states''': True}  )

										snake_case__						:       Optional[Any]       						=  self._prepare_for_class(snake_case_			,			snake_case_			,			return_labels=snake_case_  )
										snake_case__						:       Union[str, Any]       						=  self._prepare_for_class(snake_case_			,			snake_case_			,			return_labels=snake_case_  )
										check_equivalence(snake_case_			,			snake_case_			,			snake_case_			,			{'''output_hidden_states''': True}  )







						def       __magic_name__							(							self					:      Optional[Any]  ):



								'''simple docstring'''



								snake_case__						:       List[str]       						=  self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*snake_case_  )







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



								'''simple docstring'''



								for model_name in TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										snake_case__						:       Optional[Any]       						=  TFRegNetModel.from_pretrained(snake_case_  )
										self.assertIsNotNone(snake_case_  )





def 	_a       (				):

		"""simple docstring"""

		snake_case__						:       Union[str, Any]       						=  Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''     )
		return image





@require_tf
@require_vision
class     a			(				unittest.TestCase       ):






						"""simple docstring"""




						@cached_property
						def       __magic_name__							(							self					:      Dict  ):



								'''simple docstring'''



								return (
								    AutoImageProcessor.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )
								    if is_vision_available()
								    else None
								)







						@slow
						def       __magic_name__							(							self					:      Any  ):



								'''simple docstring'''



								snake_case__						:       int       						=  TFRegNetForImageClassification.from_pretrained(TF_REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]  )

								snake_case__						:       Optional[Any]       						=  self.default_image_processor
								snake_case__						:       Dict       						=  prepare_img()
								snake_case__						:       Tuple       						=  image_processor(images=snake_case_			,			return_tensors='''tf'''  )

								# forward pass
								snake_case__						:       Any       						=  model(**snake_case_			,			training=snake_case_  )

								# verify the logits
								snake_case__						:       str       						=  tf.TensorShape((1, 1_0_0_0)  )
								self.assertEqual(outputs.logits.shape			,			snake_case_  )

								snake_case__						:       int       						=  tf.constant([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]  )

								tf.debugging.assert_near(outputs.logits[0, :3]			,			snake_case_			,			atol=1e-4  )






'''simple docstring'''


from collections.abc import Generator




def 	_a       (				):

		"""simple docstring"""

		snake_case__						,       snake_case__						:       List[Any]       						=  0, 1
		while True:
				snake_case__						,       snake_case__						:       str       						=  b, a + b
				yield b




def 	_a       (				__lowerCAmelCase		:      int = 10_00     ):

		"""simple docstring"""

		snake_case__						:       Optional[int]       						=  1
		snake_case__						:       Tuple       						=  fibonacci_generator()
		while len(str(next(__lowerCAmelCase     )     )     ) < n:
				answer += 1
		return answer + 1


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



