






'''simple docstring'''







import inspect
import unittest

from transformers import RegNetConfig, is_flax_available
from transformers.testing_utils import require_flax, slow
from transformers.utils import cached_property, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_flax_common import FlaxModelTesterMixin, floats_tensor


if is_flax_available():
							import jax
							import jax.numpy as jnp

							from transformers.models.regnet.modeling_flax_regnet import FlaxRegNetForImageClassification, FlaxRegNetModel

if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor




class 		UpperCamelCase__     (unittest.TestCase      ):




		'''simple docstring'''





		def __init__(   self ,_lowerCAmelCase ,_lowerCAmelCase=3 ,_lowerCAmelCase=32 ,_lowerCAmelCase=3 ,_lowerCAmelCase=10 ,_lowerCAmelCase=[10, 20, 30, 40] ,_lowerCAmelCase=[1, 1, 2, 1] ,_lowerCAmelCase=True ,_lowerCAmelCase=True ,_lowerCAmelCase="relu" ,_lowerCAmelCase=3 ,_lowerCAmelCase=None ,):
								lowerCamelCase__								=	parent
								lowerCamelCase__								=	batch_size
								lowerCamelCase__								=	image_size
								lowerCamelCase__								=	num_channels
								lowerCamelCase__								=	embeddings_size
								lowerCamelCase__								=	hidden_sizes
								lowerCamelCase__								=	depths
								lowerCamelCase__								=	is_training
								lowerCamelCase__								=	use_labels
								lowerCamelCase__								=	hidden_act
								lowerCamelCase__								=	num_labels
								lowerCamelCase__								=	scope
								lowerCamelCase__								=	len(_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

								lowerCamelCase__								=	self.get_config()

								return config, pixel_values






		def       UpperCamelCase_       (   self							):
								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 ,image_size=self.image_size ,)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	FlaxRegNetModel(config=_lowerCAmelCase							)
								lowerCamelCase__								=	model(_lowerCAmelCase							)

								# Output shape (b, c, h, w)
								self.parent.assertEqual(
								    result.last_hidden_state.shape ,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32) ,)






		def       UpperCamelCase_       (   self ,_lowerCAmelCase ,_lowerCAmelCase							):
								lowerCamelCase__								=	self.num_labels
								lowerCamelCase__								=	FlaxRegNetForImageClassification(config=_lowerCAmelCase							)
								lowerCamelCase__								=	model(_lowerCAmelCase							)
								self.parent.assertEqual(result.logits.shape ,(self.batch_size, self.num_labels)							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.prepare_config_and_inputs()
								lowerCamelCase__							,      lowerCamelCase__								=	config_and_inputs
								lowerCamelCase__								=	{"""pixel_values""": pixel_values}
								return config, inputs_dict




@require_flax
class 		UpperCamelCase__     (a ,unittest.TestCase      ):




		'''simple docstring'''





		_UpperCamelCase						=       (FlaxRegNetModel, FlaxRegNetForImageClassification) if is_flax_available() else ()

		_UpperCamelCase						=       False
		_UpperCamelCase						=       False
		_UpperCamelCase						=       False






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	FlaxRegNetModelTester(self							)
								lowerCamelCase__								=	ConfigTester(self ,config_class=_lowerCAmelCase ,has_text_modality=_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								self.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.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()






		def       UpperCamelCase_       (   self							):
								return






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase							)






		@unittest.skip(reason="""RegNet does not use inputs_embeds"""							)
		def       UpperCamelCase_       (   self							):
								pass






		@unittest.skip(reason="""RegNet does not support input and output embeddings"""							)
		def       UpperCamelCase_       (   self							):
								pass






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

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

														lowerCamelCase__								=	["""pixel_values"""]
														self.assertListEqual(arg_names[:1] ,_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								def check_hidden_states_output(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							):
														lowerCamelCase__								=	model_class(_lowerCAmelCase							)

														lowerCamelCase__								=	model(**self._prepare_for_class(_lowerCAmelCase ,_lowerCAmelCase							)							)

														lowerCamelCase__								=	outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

														lowerCamelCase__								=	self.model_tester.num_stages
														self.assertEqual(len(_lowerCAmelCase							) ,expected_num_stages + 1							)

								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														lowerCamelCase__								=	True
														check_hidden_states_output(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							)

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

														check_hidden_states_output(_lowerCAmelCase ,_lowerCAmelCase ,_lowerCAmelCase							)






		def       UpperCamelCase_       (   self							):
								lowerCamelCase__							,      lowerCamelCase__								=	self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
														with self.subTest(model_class.__name__							):
																				lowerCamelCase__								=	self._prepare_for_class(_lowerCAmelCase ,_lowerCAmelCase							)
																				lowerCamelCase__								=	model_class(_lowerCAmelCase							)

																				@jax.jit
																				def model_jitted(_lowerCAmelCase ,**_lowerCAmelCase							):
																										return model(pixel_values=_lowerCAmelCase ,**_lowerCAmelCase							)

																				with self.subTest("""JIT Enabled"""							):
																										lowerCamelCase__								=	model_jitted(**_lowerCAmelCase							).to_tuple()

																				with self.subTest("""JIT Disabled"""							):
																										with jax.disable_jit():
																																lowerCamelCase__								=	model_jitted(**_lowerCAmelCase							).to_tuple()

																				self.assertEqual(len(_lowerCAmelCase							) ,len(_lowerCAmelCase							)							)
																				for jitted_output, output in zip(_lowerCAmelCase ,_lowerCAmelCase							):
																										self.assertEqual(jitted_output.shape ,output.shape							)



def     A__      (					):
						lowerCamelCase__								=	Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""    )
						return image





@require_flax
class 		UpperCamelCase__     (unittest.TestCase      ):




		'''simple docstring'''





		@cached_property
		def       UpperCamelCase_       (   self							):
								return AutoImageProcessor.from_pretrained("""facebook/regnet-y-040"""							) if is_vision_available() else None






		@slow
		def       UpperCamelCase_       (   self							):
								lowerCamelCase__								=	FlaxRegNetForImageClassification.from_pretrained("""facebook/regnet-y-040"""							)

								lowerCamelCase__								=	self.default_image_processor
								lowerCamelCase__								=	prepare_img()
								lowerCamelCase__								=	image_processor(images=_lowerCAmelCase ,return_tensors="""np"""							)

								lowerCamelCase__								=	model(**_lowerCAmelCase							)

								# verify the logits
								lowerCamelCase__								=	(1, 10_00)
								self.assertEqual(outputs.logits.shape ,_lowerCAmelCase							)

								lowerCamelCase__								=	jnp.array([-0.4180, -1.5051, -3.4836]							)

								self.assertTrue(jnp.allclose(outputs.logits[0, :3] ,_lowerCAmelCase ,atol=1E-4							)							)







"""simple docstring"""




def        a__					(							snake_case__ = 10_00							)		->   int:
			lowerCamelCase ,  lowerCamelCase      =   1, 1
			lowerCamelCase      =   2
			while True:
						lowerCamelCase      =   0
						lowerCamelCase      =   fa + fa
						lowerCamelCase ,  lowerCamelCase      =   fa, f
						index += 1
						for _ in str(snake_case__							):
									i += 1
						if i == n:
									break
			return index


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



