

'''simple docstring'''
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__   (	A__  ):
		A__					=    42
		A__					=    42







class 							A__   (	nn.Module  ):
		A__					=    42
		A__					=    (16, 32, 96, 2_56)
		A__					=    jnp.floataa





		def 						A  (		self				:     Any			)     ->   Optional[Any]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =nn.Conv(
							    self.block_out_channels[0]							, kernel_size=(3, 3)							, padding=((1, 1), (1, 1))							, dtype=self.dtype							, )

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

							_SCREAMING_SNAKE_CASE							   =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				:     Tuple							, _a				:     List[str]			)     ->   Any:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.conv_in(_a			)
							_SCREAMING_SNAKE_CASE							   =nn.silu(_a			)

							for block in self.blocks:
												_SCREAMING_SNAKE_CASE							   =block(_a			)
												_SCREAMING_SNAKE_CASE							   =nn.silu(_a			)

							_SCREAMING_SNAKE_CASE							   =self.conv_out(_a			)

							return embedding







@flax_register_to_config
class 							A__   (	nn.Module					,       A__					,       A__  ):
		A__					=    32
		A__					=    4
		A__					=    (
		    'CrossAttnDownBlock2D',
		    'CrossAttnDownBlock2D',
		    'CrossAttnDownBlock2D',
		    'DownBlock2D',
		)
		A__					=    False
		A__					=    (3_20, 6_40, 12_80, 12_80)
		A__					=    2
		A__					=    8
		A__					=    None
		A__					=    12_80
		A__					=    0.0
		A__					=    False
		A__					=    jnp.floataa
		A__					=    True
		A__					=    0
		A__					=    'rgb'
		A__					=    (16, 32, 96, 2_56)





		def 						A  (		self				:     List[str]							, _a				:     jax.random.KeyArray			)     ->   FrozenDict:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =(1, self.in_channels, self.sample_size, self.sample_size)
							_SCREAMING_SNAKE_CASE							   =jnp.zeros(_a							, dtype=jnp.floataa			)
							_SCREAMING_SNAKE_CASE							   =jnp.ones((1,)							, dtype=jnp.intaa			)
							_SCREAMING_SNAKE_CASE							   =jnp.zeros((1, 1, self.cross_attention_dim)							, dtype=jnp.floataa			)
							_SCREAMING_SNAKE_CASE							   =(1, 3, self.sample_size * 8, self.sample_size * 8)
							_SCREAMING_SNAKE_CASE							   =jnp.zeros(_a							, dtype=jnp.floataa			)

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

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





		def 						A  (		self				:     Union[str, Any]			)     ->   Any:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.block_out_channels
							_SCREAMING_SNAKE_CASE							   =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.
							_SCREAMING_SNAKE_CASE							   =self.num_attention_heads or self.attention_head_dim

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

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

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

							_SCREAMING_SNAKE_CASE							   =self.only_cross_attention
							if isinstance(_a							, _a			):
												_SCREAMING_SNAKE_CASE							   =(only_cross_attention,) * len(self.down_block_types			)

							if isinstance(_a							, _a			):
												_SCREAMING_SNAKE_CASE							   =(num_attention_heads,) * len(self.down_block_types			)

							# down
							_SCREAMING_SNAKE_CASE							   =[]
							_SCREAMING_SNAKE_CASE							   =[]

							_SCREAMING_SNAKE_CASE							   =block_out_channels[0]

							_SCREAMING_SNAKE_CASE							   =nn.Conv(
							    _a							, 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(_a			)

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

												if down_block_type == "CrossAttnDownBlock2D":
																	_SCREAMING_SNAKE_CASE							   =FlaxCrossAttnDownBlockaD(
																	    in_channels=_a							, out_channels=_a							, 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:
																	_SCREAMING_SNAKE_CASE							   =FlaxDownBlockaD(
																	    in_channels=_a							, out_channels=_a							, dropout=self.dropout							, num_layers=self.layers_per_block							, add_downsample=not is_final_block							, dtype=self.dtype							, )

												down_blocks.append(_a			)

												for _ in range(self.layers_per_block			):
																	_SCREAMING_SNAKE_CASE							   =nn.Conv(
																	    _a							, 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(_a			)

												if not is_final_block:
																	_SCREAMING_SNAKE_CASE							   =nn.Conv(
																	    _a							, 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(_a			)

							_SCREAMING_SNAKE_CASE							   =down_blocks
							_SCREAMING_SNAKE_CASE							   =controlnet_down_blocks

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

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





		def __call__(		self				:     Optional[Any]							, _a				:     int							, _a				:     Any							, _a				:     List[str]							, _a				:     List[str]							, _a				:     float = 1.0							, _a				:     bool = True							, _a				:     bool = False							, )     ->   Union[FlaxControlNetOutput, Tuple]:





							'''simple docstring'''






							_SCREAMING_SNAKE_CASE							   =self.controlnet_conditioning_channel_order
							if channel_order == "bgr":
												_SCREAMING_SNAKE_CASE							   =jnp.flip(_a							, axis=1			)

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

							_SCREAMING_SNAKE_CASE							   =self.time_proj(_a			)
							_SCREAMING_SNAKE_CASE							   =self.time_embedding(_a			)

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

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

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

							# 4. mid
							_SCREAMING_SNAKE_CASE							   =self.mid_block(_a							, _a							, _a							, deterministic=not train			)

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

							_SCREAMING_SNAKE_CASE							   =controlnet_down_block_res_samples

							_SCREAMING_SNAKE_CASE							   =self.controlnet_mid_block(_a			)

							# 6. scaling
							_SCREAMING_SNAKE_CASE							   =[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=_a							, mid_block_res_sample=_a			)



'''simple docstring'''
from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt


def 	_lowerCAmelCase (						_UpperCamelCase						:					int    )				->      bool:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =int(number**0.5    )
     return number == sq * sq


def 	_lowerCAmelCase (						_UpperCamelCase						:					int							,			_UpperCamelCase						:					int							,			_UpperCamelCase						:					int							,			_UpperCamelCase						:					int							,			_UpperCamelCase						:					int							,			_UpperCamelCase						:					int    )				->      tuple[int, int]:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
     _SCREAMING_SNAKE_CASE							   =x_den * y_den * z_den
     _SCREAMING_SNAKE_CASE							   =gcd(_UpperCamelCase							,			_UpperCamelCase    )
     top //= hcf
     bottom //= hcf
     return top, bottom


def 	_lowerCAmelCase (						_UpperCamelCase						:					int = 35    )				->      int:
     """simple docstring"""




     _SCREAMING_SNAKE_CASE							   =set()
     _SCREAMING_SNAKE_CASE							   =42
     _SCREAMING_SNAKE_CASE							   =Fraction(0    )
     _SCREAMING_SNAKE_CASE							   =42

     for x_num in range(1							,			order + 1    ):
          for x_den in range(x_num + 1							,			order + 1    ):
               for y_num in range(1							,			order + 1    ):
                    for y_den in range(y_num + 1							,			order + 1    ):
                         # n=1
                         _SCREAMING_SNAKE_CASE							   =x_num * y_den + x_den * y_num
                         _SCREAMING_SNAKE_CASE							   =x_den * y_den
                         _SCREAMING_SNAKE_CASE							   =gcd(_UpperCamelCase							,			_UpperCamelCase    )
                         z_num //= hcf
                         z_den //= hcf
                         if 0 < z_num < z_den <= order:
                              _SCREAMING_SNAKE_CASE							   =add_three(
                                  _UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase    )
                              unique_s.add(_UpperCamelCase    )

                         # n=2
                         _SCREAMING_SNAKE_CASE							   =(
                             x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
                         )
                         _SCREAMING_SNAKE_CASE							   =x_den * x_den * y_den * y_den
                         if is_sq(_UpperCamelCase    ) and is_sq(_UpperCamelCase    ):
                              _SCREAMING_SNAKE_CASE							   =int(sqrt(_UpperCamelCase    )    )
                              _SCREAMING_SNAKE_CASE							   =int(sqrt(_UpperCamelCase    )    )
                              _SCREAMING_SNAKE_CASE							   =gcd(_UpperCamelCase							,			_UpperCamelCase    )
                              z_num //= hcf
                              z_den //= hcf
                              if 0 < z_num < z_den <= order:
                                   _SCREAMING_SNAKE_CASE							   =add_three(
                                       _UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase    )
                                   unique_s.add(_UpperCamelCase    )

                    # n=-1
                         _SCREAMING_SNAKE_CASE							   =x_num * y_num
                         _SCREAMING_SNAKE_CASE							   =x_den * y_num + x_num * y_den
                         _SCREAMING_SNAKE_CASE							   =gcd(_UpperCamelCase							,			_UpperCamelCase    )
                         z_num //= hcf
                         z_den //= hcf
                         if 0 < z_num < z_den <= order:
                              _SCREAMING_SNAKE_CASE							   =add_three(
                                  _UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase    )
                              unique_s.add(_UpperCamelCase    )

                         # n=2
                         _SCREAMING_SNAKE_CASE							   =x_num * x_num * y_num * y_num
                         _SCREAMING_SNAKE_CASE							   =(
                             x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
                         )
                         if is_sq(_UpperCamelCase    ) and is_sq(_UpperCamelCase    ):
                              _SCREAMING_SNAKE_CASE							   =int(sqrt(_UpperCamelCase    )    )
                              _SCREAMING_SNAKE_CASE							   =int(sqrt(_UpperCamelCase    )    )
                              _SCREAMING_SNAKE_CASE							   =gcd(_UpperCamelCase							,			_UpperCamelCase    )
                              z_num //= hcf
                              z_den //= hcf
                              if 0 < z_num < z_den <= order:
                                   _SCREAMING_SNAKE_CASE							   =add_three(
                                       _UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase							,			_UpperCamelCase    )
                                   unique_s.add(_UpperCamelCase    )

     for num, den in unique_s:
          total += Fraction(_UpperCamelCase							,			_UpperCamelCase    )

     return total.denominator + total.numerator


if __name__ == "__main__":
     print(f'''{solution() = }''')
