from typing import Optional, Tuple, Union

import flax
import flax.linen as nn
import jax
import jax.numpy as jnp
from flax.core.frozen_dict import FrozenDict

from ..configuration_utils import ConfigMixin, flax_register_to_config
from ..utils import BaseOutput
from .embeddings_flax import FlaxTimestepEmbedding, FlaxTimesteps
from .modeling_flax_utils import FlaxModelMixin
from .unet_ad_blocks_flax import (
    FlaxCrossAttnDownBlockaD,
    FlaxDownBlockaD,
    FlaxUNetMidBlockaDCrossAttn,
)


@flax.struct.dataclass
class 						a__							(       __snake_case		):
			A__    :       str        =      42
			A__    :       Dict        =      42






class 						a__							(       nn.Module		):
			A__    :       List[str]        =      42
			A__    :       Optional[Any]        =      (16, 32, 96, 2_56)
			A__    :       Dict        =      jnp.floataa



			def __SCREAMING_SNAKE_CASE							(						self   )			->   List[Any]:
								__a		 =       nn.Conv(
								    self.block_out_channels[0]				,						kernel_size=(3, 3)				,						padding=((1, 1), (1, 1))				,						dtype=self.dtype				,						)

								__a		 =       []
								for i in range(len(self.block_out_channels   ) - 1   ):
													__a		 =       self.block_out_channels[i]
													__a		 =       self.block_out_channels[i + 1]
													__a		 =       nn.Conv(
													    lowerCamelCase_				,						kernel_size=(3, 3)				,						padding=((1, 1), (1, 1))				,						dtype=self.dtype				,						)
													blocks.append(lowerCamelCase_   )
													__a		 =       nn.Conv(
													    lowerCamelCase_				,						kernel_size=(3, 3)				,						strides=(2, 2)				,						padding=((1, 1), (1, 1))				,						dtype=self.dtype				,						)
													blocks.append(lowerCamelCase_   )
								__a		 =       blocks

								__a		 =       nn.Conv(
								    self.conditioning_embedding_channels				,						kernel_size=(3, 3)				,						padding=((1, 1), (1, 1))				,						kernel_init=nn.initializers.zeros_init()				,						bias_init=nn.initializers.zeros_init()				,						dtype=self.dtype				,						)







			def __call__(						self				,						UpperCAmelCase   )			->   Optional[int]:
								__a		 =       self.conv_in(lowerCamelCase_   )
								__a		 =       nn.silu(lowerCamelCase_   )

								for block in self.blocks:
													__a		 =       block(lowerCamelCase_   )
													__a		 =       nn.silu(lowerCamelCase_   )

								__a		 =       self.conv_out(lowerCamelCase_   )

								return embedding






@flax_register_to_config
class 						a__							(       nn.Module				,						__snake_case				,						__snake_case		):
			A__    :       Optional[int]        =      32
			A__    :       int        =      4
			A__    :       int        =      (
			    'CrossAttnDownBlock2D',
			    'CrossAttnDownBlock2D',
			    'CrossAttnDownBlock2D',
			    'DownBlock2D',
			)
			A__    :       str        =      False
			A__    :       Union[str, Any]        =      (3_20, 6_40, 12_80, 12_80)
			A__    :       Any        =      2
			A__    :       Tuple        =      8
			A__    :       Dict        =      None
			A__    :       List[Any]        =      12_80
			A__    :       Dict        =      0.0
			A__    :       Dict        =      False
			A__    :       Dict        =      jnp.floataa
			A__    :       Union[str, Any]        =      True
			A__    :       str        =      0
			A__    :       Tuple        =      'rgb'
			A__    :       Tuple        =      (16, 32, 96, 2_56)



			def __SCREAMING_SNAKE_CASE							(						self				,						UpperCAmelCase   )			->   Any:
								__a		 =       (1, self.in_channels, self.sample_size, self.sample_size)
								__a		 =       jnp.zeros(lowerCamelCase_				,						dtype=jnp.floataa   )
								__a		 =       jnp.ones((1,)				,						dtype=jnp.intaa   )
								__a		 =       jnp.zeros((1, 1, self.cross_attention_dim)				,						dtype=jnp.floataa   )
								__a		 =       (1, 3, self.sample_size * 8, self.sample_size * 8)
								__a		 =       jnp.zeros(lowerCamelCase_				,						dtype=jnp.floataa   )

								__a ,				__a		 =       jax.random.split(lowerCamelCase_   )
								__a		 =       {'params': params_rng, 'dropout': dropout_rng}

								return self.init(lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_   )["params"]



			def __SCREAMING_SNAKE_CASE							(						self   )			->   Optional[Any]:
								__a		 =       self.block_out_channels
								__a		 =       block_out_channels[0] * 4

								# If `num_attention_heads` is not defined (which is the case for most models)
								# it will default to `attention_head_dim`. This looks weird upon first reading it and it is.
								# The reason for this behavior is to correct for incorrectly named variables that were introduced
								# when this library was created. The incorrect naming was only discovered much later in https://github.com/huggingface/diffusers/issues/2011#issuecomment-1547958131
								# Changing `attention_head_dim` to `num_attention_heads` for 40,000+ configurations is too backwards breaking
								# which is why we correct for the naming here.
								__a		 =       self.num_attention_heads or self.attention_head_dim

								# input
								__a		 =       nn.Conv(
								    block_out_channels[0]				,						kernel_size=(3, 3)				,						strides=(1, 1)				,						padding=((1, 1), (1, 1))				,						dtype=self.dtype				,						)

								# time
								__a		 =       FlaxTimesteps(
								    block_out_channels[0]				,						flip_sin_to_cos=self.flip_sin_to_cos				,						freq_shift=self.config.freq_shift   )
								__a		 =       FlaxTimestepEmbedding(lowerCamelCase_				,						dtype=self.dtype   )

								__a		 =       FlaxControlNetConditioningEmbedding(
								    conditioning_embedding_channels=block_out_channels[0]				,						block_out_channels=self.conditioning_embedding_out_channels				,						)

								__a		 =       self.only_cross_attention
								if isinstance(lowerCamelCase_				,						lowerCamelCase_   ):
													__a		 =       (only_cross_attention,) * len(self.down_block_types   )

								if isinstance(lowerCamelCase_				,						lowerCamelCase_   ):
													__a		 =       (num_attention_heads,) * len(self.down_block_types   )

								# down
								__a		 =       []
								__a		 =       []

								__a		 =       block_out_channels[0]

								__a		 =       nn.Conv(
								    lowerCamelCase_				,						kernel_size=(1, 1)				,						padding='VALID'				,						kernel_init=nn.initializers.zeros_init()				,						bias_init=nn.initializers.zeros_init()				,						dtype=self.dtype				,						)
								controlnet_down_blocks.append(lowerCamelCase_   )

								for i, down_block_type in enumerate(self.down_block_types   ):
													__a		 =       output_channel
													__a		 =       block_out_channels[i]
													__a		 =       i == len(lowerCamelCase_   ) - 1

													if down_block_type == "CrossAttnDownBlock2D":
																		__a		 =       FlaxCrossAttnDownBlockaD(
																		    in_channels=lowerCamelCase_				,						out_channels=lowerCamelCase_				,						dropout=self.dropout				,						num_layers=self.layers_per_block				,						num_attention_heads=num_attention_heads[i]				,						add_downsample=not is_final_block				,						use_linear_projection=self.use_linear_projection				,						only_cross_attention=only_cross_attention[i]				,						dtype=self.dtype				,						)
													else:
																		__a		 =       FlaxDownBlockaD(
																		    in_channels=lowerCamelCase_				,						out_channels=lowerCamelCase_				,						dropout=self.dropout				,						num_layers=self.layers_per_block				,						add_downsample=not is_final_block				,						dtype=self.dtype				,						)

													down_blocks.append(lowerCamelCase_   )

													for _ in range(self.layers_per_block   ):
																		__a		 =       nn.Conv(
																		    lowerCamelCase_				,						kernel_size=(1, 1)				,						padding='VALID'				,						kernel_init=nn.initializers.zeros_init()				,						bias_init=nn.initializers.zeros_init()				,						dtype=self.dtype				,						)
																		controlnet_down_blocks.append(lowerCamelCase_   )

													if not is_final_block:
																		__a		 =       nn.Conv(
																		    lowerCamelCase_				,						kernel_size=(1, 1)				,						padding='VALID'				,						kernel_init=nn.initializers.zeros_init()				,						bias_init=nn.initializers.zeros_init()				,						dtype=self.dtype				,						)
																		controlnet_down_blocks.append(lowerCamelCase_   )

								__a		 =       down_blocks
								__a		 =       controlnet_down_blocks

								# mid
								__a		 =       block_out_channels[-1]
								__a		 =       FlaxUNetMidBlockaDCrossAttn(
								    in_channels=lowerCamelCase_				,						dropout=self.dropout				,						num_attention_heads=num_attention_heads[-1]				,						use_linear_projection=self.use_linear_projection				,						dtype=self.dtype				,						)

								__a		 =       nn.Conv(
								    lowerCamelCase_				,						kernel_size=(1, 1)				,						padding='VALID'				,						kernel_init=nn.initializers.zeros_init()				,						bias_init=nn.initializers.zeros_init()				,						dtype=self.dtype				,						)







			def __call__(						self				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase				,						UpperCAmelCase = 1.0				,						UpperCAmelCase = True				,						UpperCAmelCase = False				,						)			->   Any:
								__a		 =       self.controlnet_conditioning_channel_order
								if channel_order == "bgr":
													__a		 =       jnp.flip(lowerCamelCase_				,						axis=1   )

								# 1. time
								if not isinstance(lowerCamelCase_				,						jnp.ndarray   ):
													__a		 =       jnp.array([timesteps]				,						dtype=jnp.intaa   )
								elif isinstance(lowerCamelCase_				,						jnp.ndarray   ) and len(timesteps.shape   ) == 0:
													__a		 =       timesteps.astype(dtype=jnp.floataa   )
													__a		 =       jnp.expand_dims(lowerCamelCase_				,						0   )

								__a		 =       self.time_proj(lowerCamelCase_   )
								__a		 =       self.time_embedding(lowerCamelCase_   )

								# 2. pre-process
								__a		 =       jnp.transpose(lowerCamelCase_				,						(0, 2, 3, 1)   )
								__a		 =       self.conv_in(lowerCamelCase_   )

								__a		 =       jnp.transpose(lowerCamelCase_				,						(0, 2, 3, 1)   )
								__a		 =       self.controlnet_cond_embedding(lowerCamelCase_   )
								sample += controlnet_cond

								# 3. down
								__a		 =       (sample,)
								for down_block in self.down_blocks:
													if isinstance(lowerCamelCase_				,						lowerCamelCase_   ):
																		__a ,				__a		 =       down_block(lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_				,						deterministic=not train   )
													else:
																		__a ,				__a		 =       down_block(lowerCamelCase_				,						lowerCamelCase_				,						deterministic=not train   )
													down_block_res_samples += res_samples

								# 4. mid
								__a		 =       self.mid_block(lowerCamelCase_				,						lowerCamelCase_				,						lowerCamelCase_				,						deterministic=not train   )

								# 5. contronet blocks
								__a		 =       ()
								for down_block_res_sample, controlnet_block in zip(lowerCamelCase_				,						self.controlnet_down_blocks   ):
													__a		 =       controlnet_block(lowerCamelCase_   )
													controlnet_down_block_res_samples += (down_block_res_sample,)

								__a		 =       controlnet_down_block_res_samples

								__a		 =       self.controlnet_mid_block(lowerCamelCase_   )

								# 6. scaling
								__a		 =       [sample * conditioning_scale for sample in down_block_res_samples]
								mid_block_res_sample *= conditioning_scale

								if not return_dict:
													return (down_block_res_samples, mid_block_res_sample)

								return FlaxControlNetOutput(
								    down_block_res_samples=lowerCamelCase_				,						mid_block_res_sample=lowerCamelCase_   )





from math import sqrt
def 							lowerCAmelCase(     __lowerCamelCase						):
					__a		 =       0
					for i in range(1				,    int(sqrt(__lowerCamelCase						) + 1						)						):
										if n % i == 0 and i != sqrt(__lowerCamelCase						):
															total += i + n // i
										elif i == sqrt(__lowerCamelCase						):
															total += i
					return total - n
def 							lowerCAmelCase(     __lowerCamelCase = 1_0000						):
					__a		 =       sum(
					    i
					    for i in range(1				,    __lowerCamelCase						)
					    if sum_of_divisors(sum_of_divisors(__lowerCamelCase						)						) == i and sum_of_divisors(__lowerCamelCase						) != i						)
					return total


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




