






'''simple docstring'''

import gc
import unittest

from parameterized import parameterized

from diffusers import FlaxUNetaDConditionModel
from diffusers.utils import is_flax_available
from diffusers.utils.testing_utils import load_hf_numpy, require_flax, slow


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




@slow
@require_flax
class      A     (   unittest.TestCase    ):






 """simple docstring"""





 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase			):
       return F"gaussian_noise_s={seed}_shape={'_'.join([str(__lowerCAmelCase			) for s in shape]			)}.npy"
 def 	_UpperCAmelCase							(				self			):
       # clean up the VRAM after each test
       super().tearDown()
       gc.collect()
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase=0      ,  __lowerCAmelCase=(4, 4, 64, 64)      ,  __lowerCAmelCase=False			):
       UpperCamelCase_					: Dict            =				jnp.bfloataa if fpaa else jnp.floataa
       UpperCamelCase_					: str            =				jnp.array(load_hf_numpy(self.get_file_format(__lowerCAmelCase      ,  __lowerCAmelCase			)			)      ,  dtype=__lowerCAmelCase			)
       return image
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase=False      ,  __lowerCAmelCase="CompVis/stable-diffusion-v1-4"			):
       UpperCamelCase_					: Union[str, Any]            =				jnp.bfloataa if fpaa else jnp.floataa
       UpperCamelCase_					: str            =				"""bf16""" if fpaa else None

       UpperCamelCase_     ,      UpperCamelCase_					: str            =				FlaxUNetaDConditionModel.from_pretrained(
           __lowerCAmelCase      ,  subfolder="""unet"""      ,  dtype=__lowerCAmelCase      ,  revision=__lowerCAmelCase			)
       return model, params
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase=0      ,  __lowerCAmelCase=(4, 77, 7_68)      ,  __lowerCAmelCase=False			):
       UpperCamelCase_					: List[str]            =				jnp.bfloataa if fpaa else jnp.floataa
       UpperCamelCase_					: int            =				jnp.array(load_hf_numpy(self.get_file_format(__lowerCAmelCase      ,  __lowerCAmelCase			)			)      ,  dtype=__lowerCAmelCase			)
       return hidden_states
 @parameterized.expand(
     [
         # fmt: off
         [83, 4, [-0.23_23, -0.13_04, 0.08_13, -0.30_93, -0.09_19, -0.15_71, -0.11_25, -0.58_06]],
         [17, 0.55, [-0.08_31, -0.24_43, 0.09_01, -0.09_19, 0.33_96, 0.01_03, -0.37_43, 0.07_01]],
         [8, 0.89, [-0.48_63, 0.08_59, 0.08_75, -0.16_58, 0.91_99, -0.01_14, 0.48_39, 0.46_39]],
         [3, 10_00, [-0.56_49, 0.24_02, -0.55_18, 0.12_48, 1.13_28, -0.24_43, -0.03_25, -1.00_78]],
         # fmt: on
     ]			)
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase      ,  __lowerCAmelCase			):
       UpperCamelCase_     ,      UpperCamelCase_					: Optional[int]            =				self.get_unet_model(model_id="""CompVis/stable-diffusion-v1-4"""      ,  fpaa=__lowerCAmelCase			)
       UpperCamelCase_					: Any            =				self.get_latents(__lowerCAmelCase      ,  fpaa=__lowerCAmelCase			)
       UpperCamelCase_					: Tuple            =				self.get_encoder_hidden_states(__lowerCAmelCase      ,  fpaa=__lowerCAmelCase			)

       UpperCamelCase_					: List[Any]            =				model.apply(
           {"""params""": params}      ,  __lowerCAmelCase      ,  jnp.array(__lowerCAmelCase      ,  dtype=jnp.intaa			)      ,  encoder_hidden_states=__lowerCAmelCase      ,  ).sample

       assert sample.shape == latents.shape

       UpperCamelCase_					: Union[str, Any]            =				jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())			)      ,  dtype=jnp.floataa			)
       UpperCamelCase_					: Any            =				jnp.array(__lowerCAmelCase      ,  dtype=jnp.floataa			)

       # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, in the same hardware
       assert jnp.allclose(__lowerCAmelCase      ,  __lowerCAmelCase      ,  atol=1E-2			)





 @parameterized.expand(
     [
         # fmt: off
         [83, 4, [0.15_14, 0.08_07, 0.16_24, 0.10_16, -0.18_96, 0.02_63, 0.06_77, 0.23_10]],
         [17, 0.55, [0.11_64, -0.02_16, 0.01_70, 0.15_89, -0.31_20, 0.10_05, -0.05_81, -0.14_58]],
         [8, 0.89, [-0.17_58, -0.01_69, 0.10_04, -0.14_11, 0.13_12, 0.11_03, -0.19_96, 0.21_39]],
         [3, 10_00, [0.12_14, 0.03_52, -0.07_31, -0.15_62, -0.09_94, -0.09_06, -0.23_40, -0.05_39]],
         # fmt: on
     ]			)
 def 	_UpperCAmelCase							(				self      ,  __lowerCAmelCase      ,  __lowerCAmelCase      ,  __lowerCAmelCase			):
       UpperCamelCase_     ,      UpperCamelCase_					: str            =				self.get_unet_model(model_id="""stabilityai/stable-diffusion-2"""      ,  fpaa=__lowerCAmelCase			)
       UpperCamelCase_					: Dict            =				self.get_latents(__lowerCAmelCase      ,  shape=(4, 4, 96, 96)      ,  fpaa=__lowerCAmelCase			)
       UpperCamelCase_					: List[Any]            =				self.get_encoder_hidden_states(__lowerCAmelCase      ,  shape=(4, 77, 10_24)      ,  fpaa=__lowerCAmelCase			)

       UpperCamelCase_					: int            =				model.apply(
           {"""params""": params}      ,  __lowerCAmelCase      ,  jnp.array(__lowerCAmelCase      ,  dtype=jnp.intaa			)      ,  encoder_hidden_states=__lowerCAmelCase      ,  ).sample

       assert sample.shape == latents.shape

       UpperCamelCase_					: Tuple            =				jnp.asarray(jax.device_get((sample[-1, -2:, -2:, :2].flatten())			)      ,  dtype=jnp.floataa			)
       UpperCamelCase_					: Dict            =				jnp.array(__lowerCAmelCase      ,  dtype=jnp.floataa			)

       # Found torch (float16) and flax (bfloat16) outputs to be within this tolerance, on the same hardware
       assert jnp.allclose(__lowerCAmelCase      ,  __lowerCAmelCase      ,  atol=1E-2			)














'''simple docstring'''

def 				snake_case       (  a_				:			int						)							->					int:





      """simple docstring"""

      if n == 1 or not isinstance(a_     , a_						):
            return 0
      elif n == 2:
            return 1
      else:
            UpperCamelCase_					: Dict            =				[0, 1]
            for i in range(2     , n + 1						):
                  sequence.append(sequence[i - 1] + sequence[i - 2]						)

            return sequence[n]



def 				snake_case       (  a_				:			int						)							->					int:





      """simple docstring"""

      UpperCamelCase_					: Any            =				0
      UpperCamelCase_					: Union[str, Any]            =				2

      while digits < n:
            index += 1
            UpperCamelCase_					: Any            =				len(str(fibonacci(a_						)						)						)

      return index



def 				snake_case       (  a_				:			int = 1_000						)							->					int:





      """simple docstring"""

      return fibonacci_digits_index(a_						)


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






