


"""simple docstring"""






import flax.linen as nn
import jax
import jax.numpy as jnp


class 			__lowerCamelCase     (    nn.Module ):

     '''simple docstring'''
     A_				:		int
     A_				:		jnp.dtype			=						jnp.floataa


     def 							_UpperCAmelCase					(					self							)				->							str:
          _a					= nn.Conv(
              self.out_channels			, kernel_size=(3, 3)			, strides=(1, 1)			, padding=((1, 1), (1, 1))			, dtype=self.dtype			, )





     def __call__(					self			, __UpperCAmelCase							)				->							Dict:
          _a					= hidden_states.shape
          _a					= jax.image.resize(
              __UpperCAmelCase			, shape=(batch, height * 2, width * 2, channels)			, method='''nearest'''			, )
          _a					= self.conv(__UpperCAmelCase							)
          return hidden_states







class 			__lowerCamelCase     (    nn.Module ):

     '''simple docstring'''
     A_				:		int
     A_				:		jnp.dtype			=						jnp.floataa


     def 							_UpperCAmelCase					(					self							)				->							str:
          _a					= nn.Conv(
              self.out_channels			, kernel_size=(3, 3)			, strides=(2, 2)			, padding=((1, 1), (1, 1))			, dtype=self.dtype			, )





     def __call__(					self			, __UpperCAmelCase							)				->							Optional[Any]:
          # pad = ((0, 0), (0, 1), (0, 1), (0, 0))  # pad height and width dim
          # hidden_states = jnp.pad(hidden_states, pad_width=pad)
          _a					= self.conv(__UpperCAmelCase							)
          return hidden_states







class 			__lowerCamelCase     (    nn.Module ):

     '''simple docstring'''
     A_				:		int
     A_				:		int			=						None
     A_				:		float			=						0.0
     A_				:		bool			=						None
     A_				:		jnp.dtype			=						jnp.floataa


     def 							_UpperCAmelCase					(					self							)				->							str:
          _a					= self.in_channels if self.out_channels is None else self.out_channels

          _a					= nn.GroupNorm(num_groups=32			, epsilon=1e-5							)
          _a					= nn.Conv(
              __UpperCAmelCase			, kernel_size=(3, 3)			, strides=(1, 1)			, padding=((1, 1), (1, 1))			, dtype=self.dtype			, )

          _a					= nn.Dense(__UpperCAmelCase			, dtype=self.dtype							)

          _a					= nn.GroupNorm(num_groups=32			, epsilon=1e-5							)
          _a					= nn.Dropout(self.dropout_prob							)
          _a					= nn.Conv(
              __UpperCAmelCase			, kernel_size=(3, 3)			, strides=(1, 1)			, padding=((1, 1), (1, 1))			, dtype=self.dtype			, )

          _a					= self.in_channels != out_channels if self.use_nin_shortcut is None else self.use_nin_shortcut

          _a					= None
          if use_nin_shortcut:
               _a					= nn.Conv(
                   __UpperCAmelCase			, kernel_size=(1, 1)			, strides=(1, 1)			, padding='''VALID'''			, dtype=self.dtype			, )





     def __call__(					self			, __UpperCAmelCase			, __UpperCAmelCase			, __UpperCAmelCase=True							)				->							Optional[Any]:
          _a					= hidden_states
          _a					= self.norma(__UpperCAmelCase							)
          _a					= nn.swish(__UpperCAmelCase							)
          _a					= self.conva(__UpperCAmelCase							)

          _a					= self.time_emb_proj(nn.swish(__UpperCAmelCase							)							)
          _a					= jnp.expand_dims(jnp.expand_dims(__UpperCAmelCase			, 1							)			, 1							)
          _a					= hidden_states + temb

          _a					= self.norma(__UpperCAmelCase							)
          _a					= nn.swish(__UpperCAmelCase							)
          _a					= self.dropout(__UpperCAmelCase			, __UpperCAmelCase							)
          _a					= self.conva(__UpperCAmelCase							)

          if self.conv_shortcut is not None:
               _a					= self.conv_shortcut(__UpperCAmelCase							)

          return hidden_states + residual







"""simple docstring"""



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

				return sequence[n]



def 						lowercase    (				__snake_case				: int	):
		lowercase_ : str							       =   0
		lowercase_ : List[str]							       =   2

		while digits < n:
				index += 1
				lowercase_ : Any							       =   len(str(fibonacci(__snake_case	)	)	)

		return index



def 						lowercase    (				__snake_case				: int = 1_0_0_0	):
		return fibonacci_digits_index(__snake_case	)


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



