





import functools
import math

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





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__ = 4096				)						->       List[str]:







			'''simple docstring'''

			UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase     	=       key.shape[-3:]
			UpperCAmelCase     	=       value.shape[-1]
			UpperCAmelCase     	=       min(UpperCamelCase__    ,    UpperCamelCase__				)
			UpperCAmelCase     	=       query / jnp.sqrt(UpperCamelCase__				)

			@functools.partial(jax.checkpoint    ,    prevent_cse=UpperCamelCase__				)
			def summarize_chunk(UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__				):
						UpperCAmelCase     	=       jnp.einsum('''...qhd,...khd->...qhk'''    ,    UpperCamelCase__    ,    UpperCamelCase__    ,    precision=UpperCamelCase__				)

						UpperCAmelCase     	=       jnp.max(UpperCamelCase__    ,    axis=-1    ,    keepdims=UpperCamelCase__				)
						UpperCAmelCase     	=       jax.lax.stop_gradient(UpperCamelCase__				)
						UpperCAmelCase     	=       jnp.exp(attn_weights - max_score				)

						UpperCAmelCase     	=       jnp.einsum('''...vhf,...qhv->...qhf'''    ,    UpperCamelCase__    ,    UpperCamelCase__    ,    precision=UpperCamelCase__				)
						UpperCAmelCase     	=       jnp.einsum('''...qhk->...qh'''    ,    UpperCamelCase__				)

						return (exp_values, exp_weights.sum(axis=-1				), max_score)

			def chunk_scanner(UpperCamelCase__				):
						# julienne key array
						UpperCAmelCase     	=       jax.lax.dynamic_slice(
						    operand=UpperCamelCase__    ,    start_indices=[0] * (key.ndim - 3) + [chunk_idx, 0, 0]    ,    slice_sizes=list(key.shape[:-3]				) + [key_chunk_size, num_heads, k_features]    ,    )

						# julienne value array
						UpperCAmelCase     	=       jax.lax.dynamic_slice(
						    operand=UpperCamelCase__    ,    start_indices=[0] * (value.ndim - 3) + [chunk_idx, 0, 0]    ,    slice_sizes=list(value.shape[:-3]				) + [key_chunk_size, num_heads, v_features]    ,    )

						return summarize_chunk(UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__				)

			UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase     	=       jax.lax.map(f=UpperCamelCase__    ,    xs=jnp.arange(0    ,    UpperCamelCase__    ,    UpperCamelCase__				)				)

			UpperCAmelCase     	=       jnp.max(UpperCamelCase__    ,    axis=0    ,    keepdims=UpperCamelCase__				)
			UpperCAmelCase     	=       jnp.exp(chunk_max - global_max				)

			chunk_values *= jnp.expand_dims(UpperCamelCase__    ,    axis=-1				)
			chunk_weights *= max_diffs

			UpperCAmelCase     	=       chunk_values.sum(axis=0				)
			UpperCAmelCase     	=       jnp.expand_dims(UpperCamelCase__    ,    -1				).sum(axis=0				)

			return all_values / all_weights





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__    ,    UpperCamelCase__=jax.lax.Precision.HIGHEST    ,    UpperCamelCase__ = 1024    ,    UpperCamelCase__ = 4096				)						->       List[str]:







			'''simple docstring'''

			UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase     	=       query.shape[-3:]

			def chunk_scanner(UpperCamelCase__    ,    UpperCamelCase__				):
						# julienne query array
						UpperCAmelCase     	=       jax.lax.dynamic_slice(
						    operand=UpperCamelCase__    ,    start_indices=([0] * (query.ndim - 3)) + [chunk_idx, 0, 0]    ,    slice_sizes=list(query.shape[:-3]				) + [min(UpperCamelCase__    ,    UpperCamelCase__				), num_heads, q_features]    ,    )

						return (
						    chunk_idx + query_chunk_size,  # unused ignore it
						    _query_chunk_attention(
						        query=UpperCamelCase__    ,    key=UpperCamelCase__    ,    value=UpperCamelCase__    ,    precision=UpperCamelCase__    ,    key_chunk_size=UpperCamelCase__				),
						)

			UpperCAmelCase	,    UpperCAmelCase     	=       jax.lax.scan(
			    f=UpperCamelCase__    ,    init=0    ,    xs=UpperCamelCase__    ,    length=math.ceil(num_q / query_chunk_size				)				)

			return jnp.concatenate(UpperCamelCase__    ,    axis=-3				)  # fuse the chunked result back

class 			A_ (nn.Module    ):
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    8
	UpperCAmelCase__      =    6_4
	UpperCAmelCase__      =    0.0
	UpperCAmelCase__      =    False
	UpperCAmelCase__      =    jnp.floataa
	def   _lowercase       (					self	):






				'''simple docstring'''







				UpperCAmelCase     	=       self.dim_head * self.heads
				UpperCAmelCase     	=       self.dim_head**-0.5

				# Weights were exported with old names {to_q, to_k, to_v, to_out}
				UpperCAmelCase     	=       nn.Dense(_A							,      use_bias=_A							,      dtype=self.dtype							,      name='''to_q'''	)
				UpperCAmelCase     	=       nn.Dense(_A							,      use_bias=_A							,      dtype=self.dtype							,      name='''to_k'''	)
				UpperCAmelCase     	=       nn.Dense(_A							,      use_bias=_A							,      dtype=self.dtype							,      name='''to_v'''	)

				UpperCAmelCase     	=       nn.Dense(self.query_dim							,      dtype=self.dtype							,      name='''to_out_0'''	)
				UpperCAmelCase     	=       nn.Dropout(rate=self.dropout	)
	def   _lowercase       (					self							,      _A	):






				'''simple docstring'''







				UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase     	=       tensor.shape
				UpperCAmelCase     	=       self.heads
				UpperCAmelCase     	=       tensor.reshape(_A							,      _A							,      _A							,      dim // head_size	)
				UpperCAmelCase     	=       jnp.transpose(_A							,      (0, 2, 1, 3)	)
				UpperCAmelCase     	=       tensor.reshape(batch_size * head_size							,      _A							,      dim // head_size	)
				return tensor
	def   _lowercase       (					self							,      _A	):






				'''simple docstring'''







				UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase     	=       tensor.shape
				UpperCAmelCase     	=       self.heads
				UpperCAmelCase     	=       tensor.reshape(batch_size // head_size							,      _A							,      _A							,      _A	)
				UpperCAmelCase     	=       jnp.transpose(_A							,      (0, 2, 1, 3)	)
				UpperCAmelCase     	=       tensor.reshape(batch_size // head_size							,      _A							,      dim * head_size	)
				return tensor







	def __call__(					self							,      _A							,      _A=None							,      _A=True	):






				'''simple docstring'''







				UpperCAmelCase     	=       hidden_states if context is None else context

				UpperCAmelCase     	=       self.query(_A	)
				UpperCAmelCase     	=       self.key(_A	)
				UpperCAmelCase     	=       self.value(_A	)

				UpperCAmelCase     	=       self.reshape_heads_to_batch_dim(_A	)
				UpperCAmelCase     	=       self.reshape_heads_to_batch_dim(_A	)
				UpperCAmelCase     	=       self.reshape_heads_to_batch_dim(_A	)

				if self.use_memory_efficient_attention:
							UpperCAmelCase     	=       query_states.transpose(1							,      0							,      2	)
							UpperCAmelCase     	=       key_states.transpose(1							,      0							,      2	)
							UpperCAmelCase     	=       value_states.transpose(1							,      0							,      2	)

							# this if statement create a chunk size for each layer of the unet
							# the chunk size is equal to the query_length dimension of the deepest layer of the unet

							UpperCAmelCase     	=       query_states.shape[-3]
							if flatten_latent_dim % 6_4 == 0:
										UpperCAmelCase     	=       int(flatten_latent_dim / 6_4	)
							elif flatten_latent_dim % 1_6 == 0:
										UpperCAmelCase     	=       int(flatten_latent_dim / 1_6	)
							elif flatten_latent_dim % 4 == 0:
										UpperCAmelCase     	=       int(flatten_latent_dim / 4	)
							else:
										UpperCAmelCase     	=       int(_A	)

							UpperCAmelCase     	=       jax_memory_efficient_attention(
							    _A							,      _A							,      _A							,      query_chunk_size=_A							,      key_chunk_size=4_0_9_6 * 4	)

							UpperCAmelCase     	=       hidden_states.transpose(1							,      0							,      2	)
				else:
							# compute attentions
							UpperCAmelCase     	=       jnp.einsum('''b i d, b j d->b i j'''							,      _A							,      _A	)
							UpperCAmelCase     	=       attention_scores * self.scale
							UpperCAmelCase     	=       nn.softmax(_A							,      axis=2	)

							# attend to values
							UpperCAmelCase     	=       jnp.einsum('''b i j, b j d -> b i d'''							,      _A							,      _A	)

				UpperCAmelCase     	=       self.reshape_batch_dim_to_heads(_A	)
				UpperCAmelCase     	=       self.proj_attn(_A	)
				return self.dropout_layer(_A							,      deterministic=_A	)

class 			A_ (nn.Module    ):
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    0.0
	UpperCAmelCase__      =    False
	UpperCAmelCase__      =    jnp.floataa
	UpperCAmelCase__      =    False
	def   _lowercase       (					self	):






				'''simple docstring'''







				UpperCAmelCase     	=       FlaxAttention(
				    self.dim							,      self.n_heads							,      self.d_head							,      self.dropout							,      self.use_memory_efficient_attention							,      dtype=self.dtype	)
				# cross attention
				UpperCAmelCase     	=       FlaxAttention(
				    self.dim							,      self.n_heads							,      self.d_head							,      self.dropout							,      self.use_memory_efficient_attention							,      dtype=self.dtype	)
				UpperCAmelCase     	=       FlaxFeedForward(dim=self.dim							,      dropout=self.dropout							,      dtype=self.dtype	)
				UpperCAmelCase     	=       nn.LayerNorm(epsilon=1E-5							,      dtype=self.dtype	)
				UpperCAmelCase     	=       nn.LayerNorm(epsilon=1E-5							,      dtype=self.dtype	)
				UpperCAmelCase     	=       nn.LayerNorm(epsilon=1E-5							,      dtype=self.dtype	)
				UpperCAmelCase     	=       nn.Dropout(rate=self.dropout	)







	def __call__(					self							,      _A							,      _A							,      _A=True	):






				'''simple docstring'''







				UpperCAmelCase     	=       hidden_states
				if self.only_cross_attention:
							UpperCAmelCase     	=       self.attna(self.norma(_A	)							,      _A							,      deterministic=_A	)
				else:
							UpperCAmelCase     	=       self.attna(self.norma(_A	)							,      deterministic=_A	)
				UpperCAmelCase     	=       hidden_states + residual

				# cross attention
				UpperCAmelCase     	=       hidden_states
				UpperCAmelCase     	=       self.attna(self.norma(_A	)							,      _A							,      deterministic=_A	)
				UpperCAmelCase     	=       hidden_states + residual

				# feed forward
				UpperCAmelCase     	=       hidden_states
				UpperCAmelCase     	=       self.ff(self.norma(_A	)							,      deterministic=_A	)
				UpperCAmelCase     	=       hidden_states + residual

				return self.dropout_layer(_A							,      deterministic=_A	)

class 			A_ (nn.Module    ):
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    1
	UpperCAmelCase__      =    0.0
	UpperCAmelCase__      =    False
	UpperCAmelCase__      =    False
	UpperCAmelCase__      =    jnp.floataa
	UpperCAmelCase__      =    False
	def   _lowercase       (					self	):






				'''simple docstring'''







				UpperCAmelCase     	=       nn.GroupNorm(num_groups=3_2							,      epsilon=1E-5	)

				UpperCAmelCase     	=       self.n_heads * self.d_head
				if self.use_linear_projection:
							UpperCAmelCase     	=       nn.Dense(_A							,      dtype=self.dtype	)
				else:
							UpperCAmelCase     	=       nn.Conv(
							    _A							,      kernel_size=(1, 1)							,      strides=(1, 1)							,      padding='''VALID'''							,      dtype=self.dtype							,      )

				UpperCAmelCase     	=       [
				    FlaxBasicTransformerBlock(
				        _A							,      self.n_heads							,      self.d_head							,      dropout=self.dropout							,      only_cross_attention=self.only_cross_attention							,      dtype=self.dtype							,      use_memory_efficient_attention=self.use_memory_efficient_attention							,      )
				    for _ in range(self.depth	)
				]

				if self.use_linear_projection:
							UpperCAmelCase     	=       nn.Dense(_A							,      dtype=self.dtype	)
				else:
							UpperCAmelCase     	=       nn.Conv(
							    _A							,      kernel_size=(1, 1)							,      strides=(1, 1)							,      padding='''VALID'''							,      dtype=self.dtype							,      )

				UpperCAmelCase     	=       nn.Dropout(rate=self.dropout	)







	def __call__(					self							,      _A							,      _A							,      _A=True	):






				'''simple docstring'''







				UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase	,    UpperCAmelCase     	=       hidden_states.shape
				UpperCAmelCase     	=       hidden_states
				UpperCAmelCase     	=       self.norm(_A	)
				if self.use_linear_projection:
							UpperCAmelCase     	=       hidden_states.reshape(_A							,      height * width							,      _A	)
							UpperCAmelCase     	=       self.proj_in(_A	)
				else:
							UpperCAmelCase     	=       self.proj_in(_A	)
							UpperCAmelCase     	=       hidden_states.reshape(_A							,      height * width							,      _A	)

				for transformer_block in self.transformer_blocks:
							UpperCAmelCase     	=       transformer_block(_A							,      _A							,      deterministic=_A	)

				if self.use_linear_projection:
							UpperCAmelCase     	=       self.proj_out(_A	)
							UpperCAmelCase     	=       hidden_states.reshape(_A							,      _A							,      _A							,      _A	)
				else:
							UpperCAmelCase     	=       hidden_states.reshape(_A							,      _A							,      _A							,      _A	)
							UpperCAmelCase     	=       self.proj_out(_A	)

				UpperCAmelCase     	=       hidden_states + residual
				return self.dropout_layer(_A							,      deterministic=_A	)

class 			A_ (nn.Module    ):
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    0.0
	UpperCAmelCase__      =    jnp.floataa
	def   _lowercase       (					self	):






				'''simple docstring'''







				UpperCAmelCase     	=       FlaxGEGLU(self.dim							,      self.dropout							,      self.dtype	)
				UpperCAmelCase     	=       nn.Dense(self.dim							,      dtype=self.dtype	)







	def __call__(					self							,      _A							,      _A=True	):






				'''simple docstring'''







				UpperCAmelCase     	=       self.net_a(_A							,      deterministic=_A	)
				UpperCAmelCase     	=       self.net_a(_A	)
				return hidden_states

class 			A_ (nn.Module    ):
	UpperCAmelCase__      =    4_2
	UpperCAmelCase__      =    0.0
	UpperCAmelCase__      =    jnp.floataa
	def   _lowercase       (					self	):






				'''simple docstring'''







				UpperCAmelCase     	=       self.dim * 4
				UpperCAmelCase     	=       nn.Dense(inner_dim * 2							,      dtype=self.dtype	)
				UpperCAmelCase     	=       nn.Dropout(rate=self.dropout	)







	def __call__(					self							,      _A							,      _A=True	):






				'''simple docstring'''







				UpperCAmelCase     	=       self.proj(_A	)
				UpperCAmelCase	,    UpperCAmelCase     	=       jnp.split(_A							,      2							,      axis=2	)
				return self.dropout_layer(hidden_linear * nn.gelu(_A	)							,      deterministic=_A	)









from math import floor, sqrt





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__				)						->       int:







			'''simple docstring'''

			UpperCAmelCase     	=       0.0
			UpperCAmelCase     	=       1.0
			UpperCAmelCase     	=       int(sqrt(UpperCamelCase__				)				)
			UpperCAmelCase     	=       root
			UpperCAmelCase     	=       0
			while integer_part != 2 * root:
						UpperCAmelCase     	=       denominator * integer_part - numerator
						UpperCAmelCase     	=       (n - numerator**2) / denominator
						UpperCAmelCase     	=       int((root + numerator) / denominator				)
						period += 1
			return period





def 		__SCREAMING_SNAKE_CASE						(       UpperCamelCase__ = 1_0000				)						->       int:







			'''simple docstring'''

			UpperCAmelCase     	=       0
			for i in range(2    ,    n + 1				):
						UpperCAmelCase     	=       sqrt(UpperCamelCase__				)
						if sr - floor(UpperCamelCase__				) != 0 and continuous_fraction_period(UpperCamelCase__				) % 2 == 1:
									count_odd_periods += 1
			return count_odd_periods


if __name__ == "__main__":
				print(F'{solution(int(input().strip()))}')



